ICA Rest API

This API can be used to interact with Illumina Connected Analytics.

Authentication

Authentication to the API can be done in multiple ways:

• For the entire API, except for the POST /tokens endpoint: API-key + JWT
• Only for the POST /tokens endpoint: API-key + Basic Authentication

API-key

JWT

Basic Authentication

Compression

The version of the OpenAPI document: 3 Generated by OpenAPI Generator (https://openapi-generator.tech)

Do not edit the class manually.

Sub-modules

libica.openapi.v3.api

libica.openapi.v3.api_client

ICA Rest API …

libica.openapi.v3.api_response

API response object.

libica.openapi.v3.configuration

ICA Rest API …

libica.openapi.v3.exceptions

ICA Rest API …

libica.openapi.v3.models

ICA Rest API …

libica.openapi.v3.rest

ICA Rest API …

libica.openapi.v3.test

Classes

class AWSDetails (**data: Any)

Expand source code

class AWSDetails(BaseModel):
    """
    AWSDetails
    """ # noqa: E501
    bucket_name: Annotated[str, Field(min_length=3, strict=True, max_length=63)] = Field(description="The name of the s3 bucket", alias="bucketName")
    key_prefix: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="Key prefix within the bucket for ICA to operate within. Data may only be created having this prefix and the given credentials will only give access to it. If not set, default is to allow operation on the full bucket. No leading slash, and must end with a trailing slash.", alias="keyPrefix")
    server_side_encryption_algorithm: Optional[StrictStr] = Field(default=None, description="Used to specify the type of server-side encryption (SSE) to be used on the object provider. This value is used to determine the Amazon S3 header \"x-amz-server-side-encryption\" value. For example, specify \"AES256\" for SSE-S3, or \"AWS:KMS\" for SSE-KMS. By default if none is specified, \"AES256\" will be used.", alias="serverSideEncryptionAlgorithm")
    server_side_encryption_key: Optional[StrictStr] = Field(default=None, description="Used to specify the server-side encryption key that might be associated with the specified server-side encryption algorithm. This value can be the AWS KMS arn key, to be used for the Amazon S3 header \"x-amz-server-side-encryption-aws-kms-key-id\" value. Value will be ignored if encryption is \"AES256\".", alias="serverSideEncryptionKey")
    __properties: ClassVar[List[str]] = ["bucketName", "keyPrefix", "serverSideEncryptionAlgorithm", "serverSideEncryptionKey"]

    @field_validator('key_prefix')
    def key_prefix_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if value is None:
            return value

        if not re.match(r"^(?!\/).*\/$", value):
            raise ValueError(r"must validate the regular expression /^(?!\/).*\/$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AWSDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if key_prefix (nullable) is None
        # and model_fields_set contains the field
        if self.key_prefix is None and "key_prefix" in self.model_fields_set:
            _dict['keyPrefix'] = None

        # set to None if server_side_encryption_algorithm (nullable) is None
        # and model_fields_set contains the field
        if self.server_side_encryption_algorithm is None and "server_side_encryption_algorithm" in self.model_fields_set:
            _dict['serverSideEncryptionAlgorithm'] = None

        # set to None if server_side_encryption_key (nullable) is None
        # and model_fields_set contains the field
        if self.server_side_encryption_key is None and "server_side_encryption_key" in self.model_fields_set:
            _dict['serverSideEncryptionKey'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AWSDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "bucketName": obj.get("bucketName"),
            "keyPrefix": obj.get("keyPrefix"),
            "serverSideEncryptionAlgorithm": obj.get("serverSideEncryptionAlgorithm"),
            "serverSideEncryptionKey": obj.get("serverSideEncryptionKey")
        })
        return _obj

AWSDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bucket_name : str

The type of the None singleton.

var key_prefix : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var server_side_encryption_algorithm : str | None

The type of the None singleton.

var server_side_encryption_key : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AWSDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AWSDetails from a JSON string

def key_prefix_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if key_prefix (nullable) is None
    # and model_fields_set contains the field
    if self.key_prefix is None and "key_prefix" in self.model_fields_set:
        _dict['keyPrefix'] = None

    # set to None if server_side_encryption_algorithm (nullable) is None
    # and model_fields_set contains the field
    if self.server_side_encryption_algorithm is None and "server_side_encryption_algorithm" in self.model_fields_set:
        _dict['serverSideEncryptionAlgorithm'] = None

    # set to None if server_side_encryption_key (nullable) is None
    # and model_fields_set contains the field
    if self.server_side_encryption_key is None and "server_side_encryption_key" in self.model_fields_set:
        _dict['serverSideEncryptionKey'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ActivationCodeDetail (**data: Any)

Expand source code

class ActivationCodeDetail(BaseModel):
    """
    ActivationCodeDetail
    """ # noqa: E501
    id: StrictStr
    allowed_slots: Annotated[int, Field(strict=True, ge=-1)] = Field(description="The allowed slot within this code, -1 means unlimited", alias="allowedSlots")
    used_slots: Annotated[int, Field(strict=True, ge=0)] = Field(description="Indicates how many slots can are used.", alias="usedSlots")
    moved_slots: Annotated[int, Field(strict=True, ge=0)] = Field(description="The slots that where moved to another activation code", alias="movedSlots")
    original_slots: Annotated[int, Field(strict=True, ge=-1)] = Field(description="The assigned allowed slot within this code, -1 means unlimited", alias="originalSlots")
    pipeline_bundle: PipelineBundle = Field(alias="pipelineBundle")
    usages: List[ActivationCodeDetailUsage]
    __properties: ClassVar[List[str]] = ["id", "allowedSlots", "usedSlots", "movedSlots", "originalSlots", "pipelineBundle", "usages"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ActivationCodeDetail from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of pipeline_bundle
        if self.pipeline_bundle:
            _dict['pipelineBundle'] = self.pipeline_bundle.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in usages (list)
        _items = []
        if self.usages:
            for _item_usages in self.usages:
                if _item_usages:
                    _items.append(_item_usages.to_dict())
            _dict['usages'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ActivationCodeDetail from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "allowedSlots": obj.get("allowedSlots"),
            "usedSlots": obj.get("usedSlots"),
            "movedSlots": obj.get("movedSlots"),
            "originalSlots": obj.get("originalSlots"),
            "pipelineBundle": PipelineBundle.from_dict(obj["pipelineBundle"]) if obj.get("pipelineBundle") is not None else None,
            "usages": [ActivationCodeDetailUsage.from_dict(_item) for _item in obj["usages"]] if obj.get("usages") is not None else None
        })
        return _obj

ActivationCodeDetail

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var allowed_slots : int

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var moved_slots : int

The type of the None singleton.

var original_slots : int

The type of the None singleton.

var pipeline_bundle : PipelineBundle

The type of the None singleton.

var usages : List[ActivationCodeDetailUsage]

The type of the None singleton.

var used_slots : int

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ActivationCodeDetail from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ActivationCodeDetail from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of pipeline_bundle
    if self.pipeline_bundle:
        _dict['pipelineBundle'] = self.pipeline_bundle.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in usages (list)
    _items = []
    if self.usages:
        for _item_usages in self.usages:
            if _item_usages:
                _items.append(_item_usages.to_dict())
        _dict['usages'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ActivationCodeDetailList (**data: Any)

Expand source code

class ActivationCodeDetailList(BaseModel):
    """
    ActivationCodeDetailList
    """ # noqa: E501
    items: List[ActivationCodeDetail]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ActivationCodeDetailList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ActivationCodeDetailList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ActivationCodeDetail.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ActivationCodeDetailList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ActivationCodeDetail]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ActivationCodeDetailList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ActivationCodeDetailList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ActivationCodeDetailUsage (**data: Any)

Expand source code

class ActivationCodeDetailUsage(BaseModel):
    """
    ActivationCodeDetailUsage
    """ # noqa: E501
    id: StrictStr
    project: Optional[Project] = None
    used_slots: Annotated[int, Field(strict=True, ge=-1)] = Field(description="Indicates how many slots can are used, -1 means unused", alias="usedSlots")
    allowed_slots: Annotated[int, Field(strict=True, ge=-1)] = Field(description="Indicates how many slots can be used, -1 means unlimited", alias="allowedSlots")
    __properties: ClassVar[List[str]] = ["id", "project", "usedSlots", "allowedSlots"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ActivationCodeDetailUsage from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of project
        if self.project:
            _dict['project'] = self.project.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ActivationCodeDetailUsage from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "project": Project.from_dict(obj["project"]) if obj.get("project") is not None else None,
            "usedSlots": obj.get("usedSlots"),
            "allowedSlots": obj.get("allowedSlots")
        })
        return _obj

ActivationCodeDetailUsage

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var allowed_slots : int

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var project : Project | None

The type of the None singleton.

var used_slots : int

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ActivationCodeDetailUsage from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ActivationCodeDetailUsage from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of project
    if self.project:
        _dict['project'] = self.project.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisBaseSpaceDataDetails (**data: Any)

Expand source code

class AnalysisBaseSpaceDataDetails(BaseModel):
    """
    AnalysisBaseSpaceDataDetails
    """ # noqa: E501
    workgroup_id: Optional[StrictStr] = Field(default=None, alias="workgroupId")
    extensions: Optional[StrictStr] = None
    path_prefix: Optional[StrictStr] = Field(default=None, alias="pathPrefix")
    __properties: ClassVar[List[str]] = ["workgroupId", "extensions", "pathPrefix"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisBaseSpaceDataDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if workgroup_id (nullable) is None
        # and model_fields_set contains the field
        if self.workgroup_id is None and "workgroup_id" in self.model_fields_set:
            _dict['workgroupId'] = None

        # set to None if extensions (nullable) is None
        # and model_fields_set contains the field
        if self.extensions is None and "extensions" in self.model_fields_set:
            _dict['extensions'] = None

        # set to None if path_prefix (nullable) is None
        # and model_fields_set contains the field
        if self.path_prefix is None and "path_prefix" in self.model_fields_set:
            _dict['pathPrefix'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisBaseSpaceDataDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "workgroupId": obj.get("workgroupId"),
            "extensions": obj.get("extensions"),
            "pathPrefix": obj.get("pathPrefix")
        })
        return _obj

AnalysisBaseSpaceDataDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var extensions : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var path_prefix : str | None

The type of the None singleton.

var workgroup_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisBaseSpaceDataDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisBaseSpaceDataDetails from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if workgroup_id (nullable) is None
    # and model_fields_set contains the field
    if self.workgroup_id is None and "workgroup_id" in self.model_fields_set:
        _dict['workgroupId'] = None

    # set to None if extensions (nullable) is None
    # and model_fields_set contains the field
    if self.extensions is None and "extensions" in self.model_fields_set:
        _dict['extensions'] = None

    # set to None if path_prefix (nullable) is None
    # and model_fields_set contains the field
    if self.path_prefix is None and "path_prefix" in self.model_fields_set:
        _dict['pathPrefix'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisCreationBatch (**data: Any)

Expand source code

class AnalysisCreationBatch(BaseModel):
    """
    AnalysisCreationBatch
    """ # noqa: E501
    id: StrictStr
    job: Optional[Job] = None
    __properties: ClassVar[List[str]] = ["id", "job"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of job
        if self.job:
            _dict['job'] = self.job.to_dict()
        # set to None if job (nullable) is None
        # and model_fields_set contains the field
        if self.job is None and "job" in self.model_fields_set:
            _dict['job'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "job": Job.from_dict(obj["job"]) if obj.get("job") is not None else None
        })
        return _obj

AnalysisCreationBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var job : Job | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisCreationBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisCreationBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of job
    if self.job:
        _dict['job'] = self.job.to_dict()
    # set to None if job (nullable) is None
    # and model_fields_set contains the field
    if self.job is None and "job" in self.model_fields_set:
        _dict['job'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisCreationBatchItemPagedListV3 (**data: Any)

Expand source code

class AnalysisCreationBatchItemPagedListV3(BaseModel):
    """
    AnalysisCreationBatchItemPagedListV3
    """ # noqa: E501
    items: List[AnalysisCreationBatchItemV3]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemPagedListV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemPagedListV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisCreationBatchItemV3.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

AnalysisCreationBatchItemPagedListV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisCreationBatchItemV3]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisCreationBatchItemPagedListV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisCreationBatchItemPagedListV3 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisCreationBatchItemPagedListV4 (**data: Any)

Expand source code

class AnalysisCreationBatchItemPagedListV4(BaseModel):
    """
    AnalysisCreationBatchItemPagedListV4
    """ # noqa: E501
    items: List[AnalysisCreationBatchItemV4]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemPagedListV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemPagedListV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisCreationBatchItemV4.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

AnalysisCreationBatchItemPagedListV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisCreationBatchItemV4]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisCreationBatchItemPagedListV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisCreationBatchItemPagedListV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisCreationBatchItemProcessing (**data: Any)

Expand source code

class AnalysisCreationBatchItemProcessing(BaseModel):
    """
    AnalysisCreationBatchItemProcessing
    """ # noqa: E501
    status: StrictStr
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['RUNNING', 'WAITING_RESOURCES', 'SUCCEEDED', 'FAILED']):
            raise ValueError("must be one of enum values ('RUNNING', 'WAITING_RESOURCES', 'SUCCEEDED', 'FAILED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemProcessing from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemProcessing from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

AnalysisCreationBatchItemProcessing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisCreationBatchItemProcessing from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisCreationBatchItemProcessing from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisCreationBatchItemRequest (**data: Any)

Expand source code

class AnalysisCreationBatchItemRequest(BaseModel):
    """
    AnalysisCreationBatchItemRequest
    """ # noqa: E501
    user_reference: StrictStr = Field(alias="userReference")
    pipeline_id: StrictStr = Field(description="The pipeline for which an analysis will be created.", alias="pipelineId")
    tags: AnalysisTag
    __properties: ClassVar[List[str]] = ["userReference", "pipelineId", "tags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "userReference": obj.get("userReference"),
            "pipelineId": obj.get("pipelineId"),
            "tags": AnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None
        })
        return _obj

AnalysisCreationBatchItemRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var tags : AnalysisTag

The type of the None singleton.

var user_reference : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisCreationBatchItemRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisCreationBatchItemRequest from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisCreationBatchItemV3 (**data: Any)

Expand source code

class AnalysisCreationBatchItemV3(BaseModel):
    """
    AnalysisCreationBatchItemV3
    """ # noqa: E501
    id: StrictStr
    request: AnalysisCreationBatchItemRequest
    processing: AnalysisCreationBatchItemProcessing
    created_analysis: Optional[AnalysisV3] = Field(default=None, alias="createdAnalysis")
    __properties: ClassVar[List[str]] = ["id", "request", "processing", "createdAnalysis"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        # override the default output from pydantic by calling `to_dict()` of created_analysis
        if self.created_analysis:
            _dict['createdAnalysis'] = self.created_analysis.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": AnalysisCreationBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": AnalysisCreationBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None,
            "createdAnalysis": AnalysisV3.from_dict(obj["createdAnalysis"]) if obj.get("createdAnalysis") is not None else None
        })
        return _obj

AnalysisCreationBatchItemV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var created_analysis : AnalysisV3 | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : AnalysisCreationBatchItemProcessing

The type of the None singleton.

var request : AnalysisCreationBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisCreationBatchItemV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisCreationBatchItemV3 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    # override the default output from pydantic by calling `to_dict()` of created_analysis
    if self.created_analysis:
        _dict['createdAnalysis'] = self.created_analysis.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisCreationBatchItemV4 (**data: Any)

Expand source code

class AnalysisCreationBatchItemV4(BaseModel):
    """
    AnalysisCreationBatchItemV4
    """ # noqa: E501
    id: StrictStr
    request: AnalysisCreationBatchItemRequest
    processing: AnalysisCreationBatchItemProcessing
    created_analysis: Optional[AnalysisV4] = Field(default=None, alias="createdAnalysis")
    __properties: ClassVar[List[str]] = ["id", "request", "processing", "createdAnalysis"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        # override the default output from pydantic by calling `to_dict()` of created_analysis
        if self.created_analysis:
            _dict['createdAnalysis'] = self.created_analysis.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisCreationBatchItemV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": AnalysisCreationBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": AnalysisCreationBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None,
            "createdAnalysis": AnalysisV4.from_dict(obj["createdAnalysis"]) if obj.get("createdAnalysis") is not None else None
        })
        return _obj

AnalysisCreationBatchItemV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var created_analysis : AnalysisV4 | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : AnalysisCreationBatchItemProcessing

The type of the None singleton.

var request : AnalysisCreationBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisCreationBatchItemV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisCreationBatchItemV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    # override the default output from pydantic by calling `to_dict()` of created_analysis
    if self.created_analysis:
        _dict['createdAnalysis'] = self.created_analysis.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisData (**data: Any)

Expand source code

class AnalysisData(BaseModel):
    """
    AnalysisData
    """ # noqa: E501
    children: Optional[List[AnalysisData]] = None
    data_id: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The id of the file/folder.", alias="dataId")
    format: Optional[DataFormat]
    name: StrictStr = Field(description="The name of the file/folder as it was processed by the analysis.")
    data_type: StrictStr = Field(alias="dataType")
    mount_path: Optional[StrictStr] = Field(default=None, description="The requested location where the input file was located on the machine that was running the pipeline.", alias="mountPath")
    __properties: ClassVar[List[str]] = ["children", "dataId", "format", "name", "dataType", "mountPath"]

    @field_validator('data_type')
    def data_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['FILE', 'FOLDER']):
            raise ValueError("must be one of enum values ('FILE', 'FOLDER')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in children (list)
        _items = []
        if self.children:
            for _item_children in self.children:
                if _item_children:
                    _items.append(_item_children.to_dict())
            _dict['children'] = _items
        # override the default output from pydantic by calling `to_dict()` of format
        if self.format:
            _dict['format'] = self.format.to_dict()
        # set to None if format (nullable) is None
        # and model_fields_set contains the field
        if self.format is None and "format" in self.model_fields_set:
            _dict['format'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "children": [AnalysisData.from_dict(_item) for _item in obj["children"]] if obj.get("children") is not None else None,
            "dataId": obj.get("dataId"),
            "format": DataFormat.from_dict(obj["format"]) if obj.get("format") is not None else None,
            "name": obj.get("name"),
            "dataType": obj.get("dataType"),
            "mountPath": obj.get("mountPath")
        })
        return _obj

AnalysisData

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var children : List[AnalysisData] | None

The type of the None singleton.

var data_id : str

The type of the None singleton.

var data_type : str

The type of the None singleton.

var format : DataFormat | None

The type of the None singleton.

var model_config

The type of the None singleton.

var mount_path : str | None

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def data_type_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in children (list)
    _items = []
    if self.children:
        for _item_children in self.children:
            if _item_children:
                _items.append(_item_children.to_dict())
        _dict['children'] = _items
    # override the default output from pydantic by calling `to_dict()` of format
    if self.format:
        _dict['format'] = self.format.to_dict()
    # set to None if format (nullable) is None
    # and model_fields_set contains the field
    if self.format is None and "format" in self.model_fields_set:
        _dict['format'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisDataInput (**data: Any)

Expand source code

class AnalysisDataInput(BaseModel):
    """
    AnalysisDataInput
    """ # noqa: E501
    parameter_code: StrictStr = Field(alias="parameterCode")
    data_ids: Optional[List[StrictStr]] = Field(default=None, alias="dataIds")
    mounts: Optional[List[Optional[AnalysisInputDataMount]]] = None
    external_data: Optional[List[Optional[AnalysisInputExternalData]]] = Field(default=None, alias="externalData")
    __properties: ClassVar[List[str]] = ["parameterCode", "dataIds", "mounts", "externalData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisDataInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in mounts (list)
        _items = []
        if self.mounts:
            for _item_mounts in self.mounts:
                if _item_mounts:
                    _items.append(_item_mounts.to_dict())
            _dict['mounts'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
        _items = []
        if self.external_data:
            for _item_external_data in self.external_data:
                if _item_external_data:
                    _items.append(_item_external_data.to_dict())
            _dict['externalData'] = _items
        # set to None if mounts (nullable) is None
        # and model_fields_set contains the field
        if self.mounts is None and "mounts" in self.model_fields_set:
            _dict['mounts'] = None

        # set to None if external_data (nullable) is None
        # and model_fields_set contains the field
        if self.external_data is None and "external_data" in self.model_fields_set:
            _dict['externalData'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisDataInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "parameterCode": obj.get("parameterCode"),
            "dataIds": obj.get("dataIds"),
            "mounts": [AnalysisInputDataMount.from_dict(_item) for _item in obj["mounts"]] if obj.get("mounts") is not None else None,
            "externalData": [AnalysisInputExternalData.from_dict(_item) for _item in obj["externalData"]] if obj.get("externalData") is not None else None
        })
        return _obj

AnalysisDataInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_ids : List[str] | None

The type of the None singleton.

var external_data : List[AnalysisInputExternalData | None] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var mounts : List[AnalysisInputDataMount | None] | None

The type of the None singleton.

var parameter_code : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisDataInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisDataInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in mounts (list)
    _items = []
    if self.mounts:
        for _item_mounts in self.mounts:
            if _item_mounts:
                _items.append(_item_mounts.to_dict())
        _dict['mounts'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
    _items = []
    if self.external_data:
        for _item_external_data in self.external_data:
            if _item_external_data:
                _items.append(_item_external_data.to_dict())
        _dict['externalData'] = _items
    # set to None if mounts (nullable) is None
    # and model_fields_set contains the field
    if self.mounts is None and "mounts" in self.model_fields_set:
        _dict['mounts'] = None

    # set to None if external_data (nullable) is None
    # and model_fields_set contains the field
    if self.external_data is None and "external_data" in self.model_fields_set:
        _dict['externalData'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisExternalData (**data: Any)

Expand source code

class AnalysisExternalData(BaseModel):
    """
    The external data used as input by the analysis.
    """ # noqa: E501
    url: StrictStr
    type: StrictStr = Field(description="Possible values are: s3, http, basespace. More types could be added in a future release.")
    mount_path: StrictStr = Field(alias="mountPath")
    __properties: ClassVar[List[str]] = ["url", "type", "mountPath"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisExternalData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisExternalData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "url": obj.get("url"),
            "type": obj.get("type"),
            "mountPath": obj.get("mountPath")
        })
        return _obj

The external data used as input by the analysis.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var mount_path : str

The type of the None singleton.

var type : str

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisExternalData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisExternalData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisInput (**data: Any)

Expand source code

class AnalysisInput(BaseModel):
    """
    AnalysisInput
    """ # noqa: E501
    code: StrictStr = Field(description="The name of the input-parameter.")
    analysis_data: Optional[List[AnalysisData]] = Field(default=None, description="The analysis-data used as input by the analysis.", alias="analysisData")
    external_data: Optional[List[Optional[AnalysisExternalData]]] = Field(default=None, description="The external data used as input by the analysis.", alias="externalData")
    __properties: ClassVar[List[str]] = ["code", "analysisData", "externalData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_data (list)
        _items = []
        if self.analysis_data:
            for _item_analysis_data in self.analysis_data:
                if _item_analysis_data:
                    _items.append(_item_analysis_data.to_dict())
            _dict['analysisData'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
        _items = []
        if self.external_data:
            for _item_external_data in self.external_data:
                if _item_external_data:
                    _items.append(_item_external_data.to_dict())
            _dict['externalData'] = _items
        # set to None if analysis_data (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_data is None and "analysis_data" in self.model_fields_set:
            _dict['analysisData'] = None

        # set to None if external_data (nullable) is None
        # and model_fields_set contains the field
        if self.external_data is None and "external_data" in self.model_fields_set:
            _dict['externalData'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "analysisData": [AnalysisData.from_dict(_item) for _item in obj["analysisData"]] if obj.get("analysisData") is not None else None,
            "externalData": [AnalysisExternalData.from_dict(_item) for _item in obj["externalData"]] if obj.get("externalData") is not None else None
        })
        return _obj

AnalysisInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_data : List[AnalysisData] | None

The type of the None singleton.

var code : str

The type of the None singleton.

var external_data : List[AnalysisExternalData | None] | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_data (list)
    _items = []
    if self.analysis_data:
        for _item_analysis_data in self.analysis_data:
            if _item_analysis_data:
                _items.append(_item_analysis_data.to_dict())
        _dict['analysisData'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
    _items = []
    if self.external_data:
        for _item_external_data in self.external_data:
            if _item_external_data:
                _items.append(_item_external_data.to_dict())
        _dict['externalData'] = _items
    # set to None if analysis_data (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_data is None and "analysis_data" in self.model_fields_set:
        _dict['analysisData'] = None

    # set to None if external_data (nullable) is None
    # and model_fields_set contains the field
    if self.external_data is None and "external_data" in self.model_fields_set:
        _dict['externalData'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisInputDataMount (**data: Any)

Expand source code

class AnalysisInputDataMount(BaseModel):
    """
    AnalysisInputDataMount
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    mount_path: StrictStr = Field(description="The mount path is the location where the input file will be located on the machine that is running the pipeline. The use of a relative path is encouraged, but an absolute path is also allowed. The path should end with the file name, which may differ from the original input data.", alias="mountPath")
    __properties: ClassVar[List[str]] = ["dataId", "mountPath"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisInputDataMount from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisInputDataMount from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId"),
            "mountPath": obj.get("mountPath")
        })
        return _obj

AnalysisInputDataMount

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var mount_path : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisInputDataMount from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisInputDataMount from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisInputExternalData (**data: Any)

Expand source code

class AnalysisInputExternalData(BaseModel):
    """
    AnalysisInputExternalData
    """ # noqa: E501
    url: StrictStr
    type: Annotated[str, Field(strict=True)]
    mount_path: Optional[StrictStr] = Field(default=None, description="The mount path is the location where the input file will be located on the machine that is running the pipeline. The use of a relative path is encouraged, but an absolute path is also allowed. The path should end with the file name, which may differ from the original input data.", alias="mountPath")
    s3_details: Optional[AnalysisS3DataDetails] = Field(default=None, alias="s3Details")
    basespace_details: Optional[AnalysisBaseSpaceDataDetails] = Field(default=None, alias="basespaceDetails")
    __properties: ClassVar[List[str]] = ["url", "type", "mountPath", "s3Details", "basespaceDetails"]

    @field_validator('type')
    def type_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"s3|http|basespace", value):
            raise ValueError(r"must validate the regular expression /s3|http|basespace/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisInputExternalData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of s3_details
        if self.s3_details:
            _dict['s3Details'] = self.s3_details.to_dict()
        # override the default output from pydantic by calling `to_dict()` of basespace_details
        if self.basespace_details:
            _dict['basespaceDetails'] = self.basespace_details.to_dict()
        # set to None if mount_path (nullable) is None
        # and model_fields_set contains the field
        if self.mount_path is None and "mount_path" in self.model_fields_set:
            _dict['mountPath'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisInputExternalData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "url": obj.get("url"),
            "type": obj.get("type"),
            "mountPath": obj.get("mountPath"),
            "s3Details": AnalysisS3DataDetails.from_dict(obj["s3Details"]) if obj.get("s3Details") is not None else None,
            "basespaceDetails": AnalysisBaseSpaceDataDetails.from_dict(obj["basespaceDetails"]) if obj.get("basespaceDetails") is not None else None
        })
        return _obj

AnalysisInputExternalData

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var basespace_details : AnalysisBaseSpaceDataDetails | None

The type of the None singleton.

var model_config

The type of the None singleton.

var mount_path : str | None

The type of the None singleton.

var s3_details : AnalysisS3DataDetails | None

The type of the None singleton.

var type : str

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisInputExternalData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisInputExternalData from a JSON string

def type_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of s3_details
    if self.s3_details:
        _dict['s3Details'] = self.s3_details.to_dict()
    # override the default output from pydantic by calling `to_dict()` of basespace_details
    if self.basespace_details:
        _dict['basespaceDetails'] = self.basespace_details.to_dict()
    # set to None if mount_path (nullable) is None
    # and model_fields_set contains the field
    if self.mount_path is None and "mount_path" in self.model_fields_set:
        _dict['mountPath'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisInputList (**data: Any)

Expand source code

class AnalysisInputList(BaseModel):
    """
    AnalysisInputList
    """ # noqa: E501
    items: List[AnalysisInput]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisInputList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisInputList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisInput.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

AnalysisInputList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisInput]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisInputList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisInputList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisOutput (**data: Any)

Expand source code

class AnalysisOutput(BaseModel):
    """
    AnalysisOutput
    """ # noqa: E501
    code: StrictStr = Field(description="The name of the output-parameter.")
    project_id: Optional[StrictStr] = Field(default=None, description="The ID of the project containing the analysis-data produced by the analysis for the output-parameter.", alias="projectId")
    data: Optional[List[AnalysisData]] = None
    __properties: ClassVar[List[str]] = ["code", "projectId", "data"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisOutput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in data (list)
        _items = []
        if self.data:
            for _item_data in self.data:
                if _item_data:
                    _items.append(_item_data.to_dict())
            _dict['data'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisOutput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "projectId": obj.get("projectId"),
            "data": [AnalysisData.from_dict(_item) for _item in obj["data"]] if obj.get("data") is not None else None
        })
        return _obj

AnalysisOutput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str

The type of the None singleton.

var data : List[AnalysisData] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var project_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisOutput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisOutput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in data (list)
    _items = []
    if self.data:
        for _item_data in self.data:
            if _item_data:
                _items.append(_item_data.to_dict())
        _dict['data'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisOutputList (**data: Any)

Expand source code

class AnalysisOutputList(BaseModel):
    """
    AnalysisOutputList
    """ # noqa: E501
    items: List[AnalysisOutput]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisOutputList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisOutputList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisOutput.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

AnalysisOutputList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisOutput]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisOutputList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisOutputList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisOutputMapping (**data: Any)

Expand source code

class AnalysisOutputMapping(BaseModel):
    """
    AnalysisOutputMapping
    """ # noqa: E501
    source_path: StrictStr = Field(alias="sourcePath")
    type: Optional[StrictStr] = None
    target_project_id: StrictStr = Field(alias="targetProjectId")
    target_path: StrictStr = Field(alias="targetPath")
    action_on_exist: Optional[StrictStr] = Field(default=None, alias="actionOnExist")
    __properties: ClassVar[List[str]] = ["sourcePath", "type", "targetProjectId", "targetPath", "actionOnExist"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['FILE', 'FOLDER']):
            raise ValueError("must be one of enum values ('FILE', 'FOLDER')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisOutputMapping from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisOutputMapping from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "sourcePath": obj.get("sourcePath"),
            "type": obj.get("type"),
            "targetProjectId": obj.get("targetProjectId"),
            "targetPath": obj.get("targetPath"),
            "actionOnExist": obj.get("actionOnExist")
        })
        return _obj

AnalysisOutputMapping

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var action_on_exist : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var source_path : str

The type of the None singleton.

var target_path : str

The type of the None singleton.

var target_project_id : str

The type of the None singleton.

var type : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisOutputMapping from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisOutputMapping from a JSON string

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisPagedListV3 (**data: Any)

Expand source code

class AnalysisPagedListV3(BaseModel):
    """
    AnalysisPagedListV3
    """ # noqa: E501
    items: List[AnalysisV3]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisPagedListV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisPagedListV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisV3.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

AnalysisPagedListV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisV3]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisPagedListV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisPagedListV3 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisPagedListV4 (**data: Any)

Expand source code

class AnalysisPagedListV4(BaseModel):
    """
    AnalysisPagedListV4
    """ # noqa: E501
    items: List[AnalysisV4]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisPagedListV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisPagedListV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisV4.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

AnalysisPagedListV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisV4]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisPagedListV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisPagedListV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisParameterInput (**data: Any)

Expand source code

class AnalysisParameterInput(BaseModel):
    """
    Supports multi-value parameters, only one of attributes 'value' or 'multiValue' must be provided
    """ # noqa: E501
    code: Optional[StrictStr] = None
    value: Optional[StrictStr] = Field(default=None, description="The value for single-value parameters.")
    multi_value: Optional[List[Optional[StrictStr]]] = Field(default=None, description="The values for multi-value parameters.", alias="multiValue")
    __properties: ClassVar[List[str]] = ["code", "value", "multiValue"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisParameterInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if value (nullable) is None
        # and model_fields_set contains the field
        if self.value is None and "value" in self.model_fields_set:
            _dict['value'] = None

        # set to None if multi_value (nullable) is None
        # and model_fields_set contains the field
        if self.multi_value is None and "multi_value" in self.model_fields_set:
            _dict['multiValue'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisParameterInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "value": obj.get("value"),
            "multiValue": obj.get("multiValue")
        })
        return _obj

Supports multi-value parameters, only one of attributes 'value' or 'multiValue' must be provided

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var multi_value : List[str | None] | None

The type of the None singleton.

var value : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisParameterInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisParameterInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if value (nullable) is None
    # and model_fields_set contains the field
    if self.value is None and "value" in self.model_fields_set:
        _dict['value'] = None

    # set to None if multi_value (nullable) is None
    # and model_fields_set contains the field
    if self.multi_value is None and "multi_value" in self.model_fields_set:
        _dict['multiValue'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisPrice (**data: Any)

Expand source code

class AnalysisPrice(BaseModel):
    """
    AnalysisPrice
    """ # noqa: E501
    amount: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="The amount of the analysis price")
    currency: Optional[StrictStr] = Field(default='iCredit', description="The currency of the analysis price")
    __properties: ClassVar[List[str]] = ["amount", "currency"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisPrice from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisPrice from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "amount": obj.get("amount"),
            "currency": obj.get("currency") if obj.get("currency") is not None else 'iCredit'
        })
        return _obj

AnalysisPrice

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var amount : float | int | None

The type of the None singleton.

var currency : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisPrice from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisPrice from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisQueryParameters (**data: Any)

Expand source code

class AnalysisQueryParameters(BaseModel):
    """
    AnalysisQueryParameters
    """ # noqa: E501
    reference: Optional[StrictStr] = Field(default=None, description="The reference to filter on.")
    user_reference: Optional[StrictStr] = Field(default=None, description="The user-reference to filter on.", alias="userReference")
    status: Optional[List[Optional[Annotated[str, Field(strict=True)]]]] = None
    user_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="The user-tags to filter on.", alias="userTags")
    technical_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="The technical-tags to filter on.", alias="technicalTags")
    reference_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="The reference-data-tags to filter on.", alias="referenceTags")
    __properties: ClassVar[List[str]] = ["reference", "userReference", "status", "userTags", "technicalTags", "referenceTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisQueryParameters from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if reference (nullable) is None
        # and model_fields_set contains the field
        if self.reference is None and "reference" in self.model_fields_set:
            _dict['reference'] = None

        # set to None if user_reference (nullable) is None
        # and model_fields_set contains the field
        if self.user_reference is None and "user_reference" in self.model_fields_set:
            _dict['userReference'] = None

        # set to None if user_tags (nullable) is None
        # and model_fields_set contains the field
        if self.user_tags is None and "user_tags" in self.model_fields_set:
            _dict['userTags'] = None

        # set to None if technical_tags (nullable) is None
        # and model_fields_set contains the field
        if self.technical_tags is None and "technical_tags" in self.model_fields_set:
            _dict['technicalTags'] = None

        # set to None if reference_tags (nullable) is None
        # and model_fields_set contains the field
        if self.reference_tags is None and "reference_tags" in self.model_fields_set:
            _dict['referenceTags'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisQueryParameters from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "reference": obj.get("reference"),
            "userReference": obj.get("userReference"),
            "status": obj.get("status"),
            "userTags": obj.get("userTags"),
            "technicalTags": obj.get("technicalTags"),
            "referenceTags": obj.get("referenceTags")
        })
        return _obj

AnalysisQueryParameters

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var reference : str | None

The type of the None singleton.

var reference_tags : List[str | None] | None

The type of the None singleton.

var status : List[str | None] | None

The type of the None singleton.

var technical_tags : List[str | None] | None

The type of the None singleton.

var user_reference : str | None

The type of the None singleton.

var user_tags : List[str | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisQueryParameters from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisQueryParameters from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if reference (nullable) is None
    # and model_fields_set contains the field
    if self.reference is None and "reference" in self.model_fields_set:
        _dict['reference'] = None

    # set to None if user_reference (nullable) is None
    # and model_fields_set contains the field
    if self.user_reference is None and "user_reference" in self.model_fields_set:
        _dict['userReference'] = None

    # set to None if user_tags (nullable) is None
    # and model_fields_set contains the field
    if self.user_tags is None and "user_tags" in self.model_fields_set:
        _dict['userTags'] = None

    # set to None if technical_tags (nullable) is None
    # and model_fields_set contains the field
    if self.technical_tags is None and "technical_tags" in self.model_fields_set:
        _dict['technicalTags'] = None

    # set to None if reference_tags (nullable) is None
    # and model_fields_set contains the field
    if self.reference_tags is None and "reference_tags" in self.model_fields_set:
        _dict['referenceTags'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisRawOutput (**data: Any)

Expand source code

class AnalysisRawOutput(BaseModel):
    """
    AnalysisRawOutput
    """ # noqa: E501
    raw_output: StrictStr = Field(description="The raw output of the analysis.", alias="rawOutput")
    __properties: ClassVar[List[str]] = ["rawOutput"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisRawOutput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisRawOutput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "rawOutput": obj.get("rawOutput")
        })
        return _obj

AnalysisRawOutput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var raw_output : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisRawOutput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisRawOutput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisReferenceDataParameter (**data: Any)

Expand source code

class AnalysisReferenceDataParameter(BaseModel):
    """
    AnalysisReferenceDataParameter
    """ # noqa: E501
    parameter_code: Optional[StrictStr] = Field(default=None, alias="parameterCode")
    reference_data_id: Optional[StrictStr] = Field(default=None, alias="referenceDataId")
    __properties: ClassVar[List[str]] = ["parameterCode", "referenceDataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisReferenceDataParameter from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisReferenceDataParameter from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "parameterCode": obj.get("parameterCode"),
            "referenceDataId": obj.get("referenceDataId")
        })
        return _obj

AnalysisReferenceDataParameter

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var parameter_code : str | None

The type of the None singleton.

var reference_data_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisReferenceDataParameter from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisReferenceDataParameter from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisReportData (**data: Any)

Expand source code

class AnalysisReportData(BaseModel):
    """
    The list of analysis report files
    """ # noqa: E501
    data_id: Optional[StrictStr] = Field(default=None, description="The data id of the report", alias="dataId")
    format: Optional[StrictStr] = Field(default=None, description="The format of the report")
    name: Optional[StrictStr] = Field(default=None, description="The name of the report file")
    __properties: ClassVar[List[str]] = ["dataId", "format", "name"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisReportData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if data_id (nullable) is None
        # and model_fields_set contains the field
        if self.data_id is None and "data_id" in self.model_fields_set:
            _dict['dataId'] = None

        # set to None if format (nullable) is None
        # and model_fields_set contains the field
        if self.format is None and "format" in self.model_fields_set:
            _dict['format'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisReportData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId"),
            "format": obj.get("format"),
            "name": obj.get("name")
        })
        return _obj

The list of analysis report files

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str | None

The type of the None singleton.

var format : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisReportData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisReportData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if data_id (nullable) is None
    # and model_fields_set contains the field
    if self.data_id is None and "data_id" in self.model_fields_set:
        _dict['dataId'] = None

    # set to None if format (nullable) is None
    # and model_fields_set contains the field
    if self.format is None and "format" in self.model_fields_set:
        _dict['format'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisReportEntry (**data: Any)

Expand source code

class AnalysisReportEntry(BaseModel):
    """
    AnalysisReportEntry
    """ # noqa: E501
    report_title: Optional[StrictStr] = Field(default=None, description="The name of the report config", alias="reportTitle")
    report_data: Optional[List[Optional[AnalysisReportData]]] = Field(default=None, description="The list of analysis report files", alias="reportData")
    __properties: ClassVar[List[str]] = ["reportTitle", "reportData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisReportEntry from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in report_data (list)
        _items = []
        if self.report_data:
            for _item_report_data in self.report_data:
                if _item_report_data:
                    _items.append(_item_report_data.to_dict())
            _dict['reportData'] = _items
        # set to None if report_title (nullable) is None
        # and model_fields_set contains the field
        if self.report_title is None and "report_title" in self.model_fields_set:
            _dict['reportTitle'] = None

        # set to None if report_data (nullable) is None
        # and model_fields_set contains the field
        if self.report_data is None and "report_data" in self.model_fields_set:
            _dict['reportData'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisReportEntry from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "reportTitle": obj.get("reportTitle"),
            "reportData": [AnalysisReportData.from_dict(_item) for _item in obj["reportData"]] if obj.get("reportData") is not None else None
        })
        return _obj

AnalysisReportEntry

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var report_data : List[AnalysisReportData | None] | None

The type of the None singleton.

var report_title : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisReportEntry from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisReportEntry from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in report_data (list)
    _items = []
    if self.report_data:
        for _item_report_data in self.report_data:
            if _item_report_data:
                _items.append(_item_report_data.to_dict())
        _dict['reportData'] = _items
    # set to None if report_title (nullable) is None
    # and model_fields_set contains the field
    if self.report_title is None and "report_title" in self.model_fields_set:
        _dict['reportTitle'] = None

    # set to None if report_data (nullable) is None
    # and model_fields_set contains the field
    if self.report_data is None and "report_data" in self.model_fields_set:
        _dict['reportData'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisReportEntryList (**data: Any)

Expand source code

class AnalysisReportEntryList(BaseModel):
    """
    AnalysisReportEntryList
    """ # noqa: E501
    items: List[AnalysisReportEntry]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisReportEntryList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisReportEntryList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisReportEntry.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

AnalysisReportEntryList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisReportEntry]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisReportEntryList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisReportEntryList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisS3DataDetails (**data: Any)

Expand source code

class AnalysisS3DataDetails(BaseModel):
    """
    AnalysisS3DataDetails
    """ # noqa: E501
    storage_credentials_id: Optional[StrictStr] = Field(default=None, description="The storage credentials with the S3 access key.", alias="storageCredentialsId")
    __properties: ClassVar[List[str]] = ["storageCredentialsId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisS3DataDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if storage_credentials_id (nullable) is None
        # and model_fields_set contains the field
        if self.storage_credentials_id is None and "storage_credentials_id" in self.model_fields_set:
            _dict['storageCredentialsId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisS3DataDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "storageCredentialsId": obj.get("storageCredentialsId")
        })
        return _obj

AnalysisS3DataDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var storage_credentials_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisS3DataDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisS3DataDetails from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if storage_credentials_id (nullable) is None
    # and model_fields_set contains the field
    if self.storage_credentials_id is None and "storage_credentials_id" in self.model_fields_set:
        _dict['storageCredentialsId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisStep (**data: Any)

Expand source code

class AnalysisStep(BaseModel):
    """
    AnalysisStep
    """ # noqa: E501
    id: StrictStr
    name: StrictStr
    status: StrictStr = Field(description="The status of the analysis step")
    queue_date: Optional[datetime] = Field(default=None, description="When the analysis step was queued", alias="queueDate")
    start_date: Optional[datetime] = Field(default=None, description="When the analysis step was started", alias="startDate")
    end_date: Optional[datetime] = Field(default=None, description="When the analysis step was finished", alias="endDate")
    technical: StrictBool = Field(description="Indicates which kind of step was executed")
    logs: AnalysisStepLogs
    exit_code: Optional[StrictInt] = Field(default=None, description="The exit code of the analysis step", alias="exitCode")
    __properties: ClassVar[List[str]] = ["id", "name", "status", "queueDate", "startDate", "endDate", "technical", "logs", "exitCode"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['FAILED', 'DONE', 'RUNNING', 'INTERRUPTED', 'ABORTED', 'WAITING']):
            raise ValueError("must be one of enum values ('FAILED', 'DONE', 'RUNNING', 'INTERRUPTED', 'ABORTED', 'WAITING')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisStep from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of logs
        if self.logs:
            _dict['logs'] = self.logs.to_dict()
        # set to None if queue_date (nullable) is None
        # and model_fields_set contains the field
        if self.queue_date is None and "queue_date" in self.model_fields_set:
            _dict['queueDate'] = None

        # set to None if start_date (nullable) is None
        # and model_fields_set contains the field
        if self.start_date is None and "start_date" in self.model_fields_set:
            _dict['startDate'] = None

        # set to None if end_date (nullable) is None
        # and model_fields_set contains the field
        if self.end_date is None and "end_date" in self.model_fields_set:
            _dict['endDate'] = None

        # set to None if exit_code (nullable) is None
        # and model_fields_set contains the field
        if self.exit_code is None and "exit_code" in self.model_fields_set:
            _dict['exitCode'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisStep from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name"),
            "status": obj.get("status"),
            "queueDate": obj.get("queueDate"),
            "startDate": obj.get("startDate"),
            "endDate": obj.get("endDate"),
            "technical": obj.get("technical"),
            "logs": AnalysisStepLogs.from_dict(obj["logs"]) if obj.get("logs") is not None else None,
            "exitCode": obj.get("exitCode")
        })
        return _obj

AnalysisStep

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var end_date : datetime.datetime | None

The type of the None singleton.

var exit_code : int | None

The type of the None singleton.

var id : str

The type of the None singleton.

var logs : AnalysisStepLogs

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var queue_date : datetime.datetime | None

The type of the None singleton.

var start_date : datetime.datetime | None

The type of the None singleton.

var status : str

The type of the None singleton.

var technical : bool

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisStep from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisStep from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of logs
    if self.logs:
        _dict['logs'] = self.logs.to_dict()
    # set to None if queue_date (nullable) is None
    # and model_fields_set contains the field
    if self.queue_date is None and "queue_date" in self.model_fields_set:
        _dict['queueDate'] = None

    # set to None if start_date (nullable) is None
    # and model_fields_set contains the field
    if self.start_date is None and "start_date" in self.model_fields_set:
        _dict['startDate'] = None

    # set to None if end_date (nullable) is None
    # and model_fields_set contains the field
    if self.end_date is None and "end_date" in self.model_fields_set:
        _dict['endDate'] = None

    # set to None if exit_code (nullable) is None
    # and model_fields_set contains the field
    if self.exit_code is None and "exit_code" in self.model_fields_set:
        _dict['exitCode'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisStepList (**data: Any)

Expand source code

class AnalysisStepList(BaseModel):
    """
    AnalysisStepList
    """ # noqa: E501
    items: List[AnalysisStep]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisStepList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisStepList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisStep.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

AnalysisStepList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisStep]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisStepList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisStepList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisStepLogs (**data: Any)

Expand source code

class AnalysisStepLogs(BaseModel):
    """
    Contains references to the standard output (stdout) and standard error (stderr) log streams of an analysis step. In this object both log streams could be provided in 2 different formats: as a WebSocket stream URL or as an ICA Data reference. The status of the analysis step determines which format is provided: a WebSocket URL during step execution, a Data reference after step execution. Note however that an analysis step might not expose log streams at all, which would result in this object being empty. 
    """ # noqa: E501
    std_out_data: Optional[Data] = Field(default=None, alias="stdOutData")
    std_out_stream: Optional[StrictStr] = Field(default=None, description="A WebSocket URL for reading the standard output log stream. Might be closed by ICA as soon as the analysis step execution has finished.", alias="stdOutStream")
    std_err_data: Optional[Data] = Field(default=None, alias="stdErrData")
    std_err_stream: Optional[StrictStr] = Field(default=None, description="A WebSocket URL for reading the standard error log stream. Might be closed by ICA as soon as the analysis step execution has finished.", alias="stdErrStream")
    __properties: ClassVar[List[str]] = ["stdOutData", "stdOutStream", "stdErrData", "stdErrStream"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisStepLogs from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of std_out_data
        if self.std_out_data:
            _dict['stdOutData'] = self.std_out_data.to_dict()
        # override the default output from pydantic by calling `to_dict()` of std_err_data
        if self.std_err_data:
            _dict['stdErrData'] = self.std_err_data.to_dict()
        # set to None if std_out_stream (nullable) is None
        # and model_fields_set contains the field
        if self.std_out_stream is None and "std_out_stream" in self.model_fields_set:
            _dict['stdOutStream'] = None

        # set to None if std_err_stream (nullable) is None
        # and model_fields_set contains the field
        if self.std_err_stream is None and "std_err_stream" in self.model_fields_set:
            _dict['stdErrStream'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisStepLogs from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "stdOutData": Data.from_dict(obj["stdOutData"]) if obj.get("stdOutData") is not None else None,
            "stdOutStream": obj.get("stdOutStream"),
            "stdErrData": Data.from_dict(obj["stdErrData"]) if obj.get("stdErrData") is not None else None,
            "stdErrStream": obj.get("stdErrStream")
        })
        return _obj

Contains references to the standard output (stdout) and standard error (stderr) log streams of an analysis step. In this object both log streams could be provided in 2 different formats: as a WebSocket stream URL or as an ICA Data reference. The status of the analysis step determines which format is provided: a WebSocket URL during step execution, a Data reference after step execution. Note however that an analysis step might not expose log streams at all, which would result in this object being empty.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var std_err_data : Data | None

The type of the None singleton.

var std_err_stream : str | None

The type of the None singleton.

var std_out_data : Data | None

The type of the None singleton.

var std_out_stream : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisStepLogs from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisStepLogs from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of std_out_data
    if self.std_out_data:
        _dict['stdOutData'] = self.std_out_data.to_dict()
    # override the default output from pydantic by calling `to_dict()` of std_err_data
    if self.std_err_data:
        _dict['stdErrData'] = self.std_err_data.to_dict()
    # set to None if std_out_stream (nullable) is None
    # and model_fields_set contains the field
    if self.std_out_stream is None and "std_out_stream" in self.model_fields_set:
        _dict['stdOutStream'] = None

    # set to None if std_err_stream (nullable) is None
    # and model_fields_set contains the field
    if self.std_err_stream is None and "std_err_stream" in self.model_fields_set:
        _dict['stdErrStream'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisStorageApi (api_client=None)

Expand source code

class AnalysisStorageApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_analysis_storage_options(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisStorageListV3:
        """(Deprecated) Retrieve the list of analysis storage options.

        This endpoint only returns V3 items. Use the search project analysis storage endpoint to get V4 items.

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/analysisStorages is deprecated.", DeprecationWarning)

        _param = self._get_analysis_storage_options_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisStorageListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_storage_options_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisStorageListV3]:
        """(Deprecated) Retrieve the list of analysis storage options.

        This endpoint only returns V3 items. Use the search project analysis storage endpoint to get V4 items.

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/analysisStorages is deprecated.", DeprecationWarning)

        _param = self._get_analysis_storage_options_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisStorageListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_storage_options_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """(Deprecated) Retrieve the list of analysis storage options.

        This endpoint only returns V3 items. Use the search project analysis storage endpoint to get V4 items.

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/analysisStorages is deprecated.", DeprecationWarning)

        _param = self._get_analysis_storage_options_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisStorageListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_storage_options_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/analysisStorages',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_analysis_storage_options(self) ‑> AnalysisStorageListV3

Expand source code

@validate_call
def get_analysis_storage_options(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisStorageListV3:
    """(Deprecated) Retrieve the list of analysis storage options.

    This endpoint only returns V3 items. Use the search project analysis storage endpoint to get V4 items.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/analysisStorages is deprecated.", DeprecationWarning)

    _param = self._get_analysis_storage_options_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisStorageListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

(Deprecated) Retrieve the list of analysis storage options.

This endpoint only returns V3 items. Use the search project analysis storage endpoint to get V4 items.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_storage_options_with_http_info(self) ‑> ApiResponse[AnalysisStorageListV3]

Expand source code

@validate_call
def get_analysis_storage_options_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisStorageListV3]:
    """(Deprecated) Retrieve the list of analysis storage options.

    This endpoint only returns V3 items. Use the search project analysis storage endpoint to get V4 items.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/analysisStorages is deprecated.", DeprecationWarning)

    _param = self._get_analysis_storage_options_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisStorageListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

(Deprecated) Retrieve the list of analysis storage options.

This endpoint only returns V3 items. Use the search project analysis storage endpoint to get V4 items.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_storage_options_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_storage_options_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Retrieve the list of analysis storage options.

    This endpoint only returns V3 items. Use the search project analysis storage endpoint to get V4 items.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/analysisStorages is deprecated.", DeprecationWarning)

    _param = self._get_analysis_storage_options_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisStorageListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

(Deprecated) Retrieve the list of analysis storage options.

This endpoint only returns V3 items. Use the search project analysis storage endpoint to get V4 items.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class AnalysisStorageListV3 (**data: Any)

Expand source code

class AnalysisStorageListV3(BaseModel):
    """
    AnalysisStorageListV3
    """ # noqa: E501
    items: List[AnalysisStorageV3]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisStorageListV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisStorageListV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisStorageV3.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

AnalysisStorageListV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisStorageV3]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisStorageListV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisStorageListV3 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisStorageListV4 (**data: Any)

Expand source code

class AnalysisStorageListV4(BaseModel):
    """
    AnalysisStorageListV4
    """ # noqa: E501
    items: List[AnalysisStorageV4]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisStorageListV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisStorageListV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [AnalysisStorageV4.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

AnalysisStorageListV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[AnalysisStorageV4]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisStorageListV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisStorageListV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisStorageV3 (**data: Any)

Expand source code

class AnalysisStorageV3(BaseModel):
    """
    AnalysisStorageV3
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the storage option")
    description: Optional[StrictStr] = Field(default=None, description="The description about the storage option")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "description"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisStorageV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisStorageV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "description": obj.get("description")
        })
        return _obj

AnalysisStorageV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisStorageV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisStorageV3 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisStorageV4 (**data: Any)

Expand source code

class AnalysisStorageV4(BaseModel):
    """
    AnalysisStorageV4
    """ # noqa: E501
    id: StrictStr
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the storage option")
    description: Optional[StrictStr] = Field(default=None, description="The description about the storage option")
    __properties: ClassVar[List[str]] = ["id", "name", "description"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisStorageV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisStorageV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name"),
            "description": obj.get("description")
        })
        return _obj

AnalysisStorageV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisStorageV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisStorageV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisTag (**data: Any)

Expand source code

class AnalysisTag(BaseModel):
    """
    AnalysisTag
    """ # noqa: E501
    technical_tags: List[StrictStr] = Field(description="Technical tags", alias="technicalTags")
    user_tags: List[StrictStr] = Field(description="User tags", alias="userTags")
    reference_tags: List[StrictStr] = Field(description="Reference tags", alias="referenceTags")
    __properties: ClassVar[List[str]] = ["technicalTags", "userTags", "referenceTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisTag from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisTag from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "technicalTags": obj.get("technicalTags"),
            "userTags": obj.get("userTags"),
            "referenceTags": obj.get("referenceTags")
        })
        return _obj

AnalysisTag

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var reference_tags : List[str]

The type of the None singleton.

var technical_tags : List[str]

The type of the None singleton.

var user_tags : List[str]

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisTag from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisTag from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisUsageDetails (**data: Any)

Expand source code

class AnalysisUsageDetails(BaseModel):
    """
    AnalysisUsageDetails
    """ # noqa: E501
    price: Optional[AnalysisPrice] = None
    __properties: ClassVar[List[str]] = ["price"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisUsageDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of price
        if self.price:
            _dict['price'] = self.price.to_dict()
        # set to None if price (nullable) is None
        # and model_fields_set contains the field
        if self.price is None and "price" in self.model_fields_set:
            _dict['price'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisUsageDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "price": AnalysisPrice.from_dict(obj["price"]) if obj.get("price") is not None else None
        })
        return _obj

AnalysisUsageDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var price : AnalysisPrice | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisUsageDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisUsageDetails from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of price
    if self.price:
        _dict['price'] = self.price.to_dict()
    # set to None if price (nullable) is None
    # and model_fields_set contains the field
    if self.price is None and "price" in self.model_fields_set:
        _dict['price'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisV3 (**data: Any)

Expand source code

class AnalysisV3(BaseModel):
    """
    AnalysisV3
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The unique reference of the analysis")
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user reference of the analysis", alias="userReference")
    pipeline: PipelineV3
    workflow_session: Optional[WorkflowSessionV3] = Field(default=None, alias="workflowSession")
    status: StrictStr = Field(description="The status of the analysis")
    start_date: Optional[datetime] = Field(default=None, description="When the analysis was started", alias="startDate")
    end_date: Optional[datetime] = Field(default=None, description="When the analysis was finished", alias="endDate")
    summary: Optional[StrictStr] = Field(default=None, description="The summary of the analysis")
    analysis_storage: Optional[AnalysisStorageV3] = Field(default=None, alias="analysisStorage")
    analysis_priority: Optional[StrictStr] = Field(default=None, description="The priority of the analysis", alias="analysisPriority")
    tags: AnalysisTag
    application: Optional[ApplicationV4] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "reference", "userReference", "pipeline", "workflowSession", "status", "startDate", "endDate", "summary", "analysisStorage", "analysisPriority", "tags", "application"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['REQUESTED', 'AWAITINGINPUT', 'INPROGRESS', 'SUCCEEDED', 'FAILED', 'FAILEDFINAL', 'ABORTED']):
            raise ValueError("must be one of enum values ('REQUESTED', 'AWAITINGINPUT', 'INPROGRESS', 'SUCCEEDED', 'FAILED', 'FAILEDFINAL', 'ABORTED')")
        return value

    @field_validator('analysis_priority')
    def analysis_priority_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['LOW', 'MEDIUM', 'HIGH']):
            raise ValueError("must be one of enum values ('LOW', 'MEDIUM', 'HIGH')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of pipeline
        if self.pipeline:
            _dict['pipeline'] = self.pipeline.to_dict()
        # override the default output from pydantic by calling `to_dict()` of workflow_session
        if self.workflow_session:
            _dict['workflowSession'] = self.workflow_session.to_dict()
        # override the default output from pydantic by calling `to_dict()` of analysis_storage
        if self.analysis_storage:
            _dict['analysisStorage'] = self.analysis_storage.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if start_date (nullable) is None
        # and model_fields_set contains the field
        if self.start_date is None and "start_date" in self.model_fields_set:
            _dict['startDate'] = None

        # set to None if end_date (nullable) is None
        # and model_fields_set contains the field
        if self.end_date is None and "end_date" in self.model_fields_set:
            _dict['endDate'] = None

        # set to None if summary (nullable) is None
        # and model_fields_set contains the field
        if self.summary is None and "summary" in self.model_fields_set:
            _dict['summary'] = None

        # set to None if analysis_priority (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_priority is None and "analysis_priority" in self.model_fields_set:
            _dict['analysisPriority'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "reference": obj.get("reference"),
            "userReference": obj.get("userReference"),
            "pipeline": PipelineV3.from_dict(obj["pipeline"]) if obj.get("pipeline") is not None else None,
            "workflowSession": WorkflowSessionV3.from_dict(obj["workflowSession"]) if obj.get("workflowSession") is not None else None,
            "status": obj.get("status"),
            "startDate": obj.get("startDate"),
            "endDate": obj.get("endDate"),
            "summary": obj.get("summary"),
            "analysisStorage": AnalysisStorageV3.from_dict(obj["analysisStorage"]) if obj.get("analysisStorage") is not None else None,
            "analysisPriority": obj.get("analysisPriority"),
            "tags": AnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None
        })
        return _obj

AnalysisV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_priority : str | None

The type of the None singleton.

var analysis_storage : AnalysisStorageV3 | None

The type of the None singleton.

var application : ApplicationV4 | None

The type of the None singleton.

var end_date : datetime.datetime | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var pipeline : PipelineV3

The type of the None singleton.

var reference : str

The type of the None singleton.

var start_date : datetime.datetime | None

The type of the None singleton.

var status : str

The type of the None singleton.

var summary : str | None

The type of the None singleton.

var tags : AnalysisTag

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var user_reference : str

The type of the None singleton.

var workflow_session : WorkflowSessionV3 | None

The type of the None singleton.

Static methods

def analysis_priority_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisV3 from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of pipeline
    if self.pipeline:
        _dict['pipeline'] = self.pipeline.to_dict()
    # override the default output from pydantic by calling `to_dict()` of workflow_session
    if self.workflow_session:
        _dict['workflowSession'] = self.workflow_session.to_dict()
    # override the default output from pydantic by calling `to_dict()` of analysis_storage
    if self.analysis_storage:
        _dict['analysisStorage'] = self.analysis_storage.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if start_date (nullable) is None
    # and model_fields_set contains the field
    if self.start_date is None and "start_date" in self.model_fields_set:
        _dict['startDate'] = None

    # set to None if end_date (nullable) is None
    # and model_fields_set contains the field
    if self.end_date is None and "end_date" in self.model_fields_set:
        _dict['endDate'] = None

    # set to None if summary (nullable) is None
    # and model_fields_set contains the field
    if self.summary is None and "summary" in self.model_fields_set:
        _dict['summary'] = None

    # set to None if analysis_priority (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_priority is None and "analysis_priority" in self.model_fields_set:
        _dict['analysisPriority'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AnalysisV4 (**data: Any)

Expand source code

class AnalysisV4(BaseModel):
    """
    AnalysisV4
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner: UserIdentifier
    tenant: TenantIdentifier
    reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The unique reference of the analysis")
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user reference of the analysis", alias="userReference")
    pipeline: PipelineV4
    workflow_session: Optional[WorkflowSessionV4] = Field(default=None, alias="workflowSession")
    status: Annotated[str, Field(strict=True)] = Field(description="The status of the analysis")
    start_date: Optional[datetime] = Field(default=None, description="When the analysis was started", alias="startDate")
    end_date: Optional[datetime] = Field(default=None, description="When the analysis was finished", alias="endDate")
    summary: Optional[StrictStr] = Field(default=None, description="The summary of the analysis")
    analysis_storage: Optional[AnalysisStorageV4] = Field(default=None, alias="analysisStorage")
    analysis_priority: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The priority of the analysis", alias="analysisPriority")
    tags: AnalysisTag
    application: Optional[ApplicationV4] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "owner", "tenant", "reference", "userReference", "pipeline", "workflowSession", "status", "startDate", "endDate", "summary", "analysisStorage", "analysisPriority", "tags", "application"]

    @field_validator('status')
    def status_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"REQUESTED|QUEUED|INITIALIZING|PREPARING_INPUTS|IN_PROGRESS|GENERATING_OUTPUTS|AWAITING_INPUT|ABORTING|SUCCEEDED|FAILED|FAILED_FINAL|ABORTED", value):
            raise ValueError(r"must validate the regular expression /REQUESTED|QUEUED|INITIALIZING|PREPARING_INPUTS|IN_PROGRESS|GENERATING_OUTPUTS|AWAITING_INPUT|ABORTING|SUCCEEDED|FAILED|FAILED_FINAL|ABORTED/")
        return value

    @field_validator('analysis_priority')
    def analysis_priority_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if value is None:
            return value

        if not re.match(r"LOW|MEDIUM|HIGH", value):
            raise ValueError(r"must validate the regular expression /LOW|MEDIUM|HIGH/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AnalysisV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of owner
        if self.owner:
            _dict['owner'] = self.owner.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tenant
        if self.tenant:
            _dict['tenant'] = self.tenant.to_dict()
        # override the default output from pydantic by calling `to_dict()` of pipeline
        if self.pipeline:
            _dict['pipeline'] = self.pipeline.to_dict()
        # override the default output from pydantic by calling `to_dict()` of workflow_session
        if self.workflow_session:
            _dict['workflowSession'] = self.workflow_session.to_dict()
        # override the default output from pydantic by calling `to_dict()` of analysis_storage
        if self.analysis_storage:
            _dict['analysisStorage'] = self.analysis_storage.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # set to None if start_date (nullable) is None
        # and model_fields_set contains the field
        if self.start_date is None and "start_date" in self.model_fields_set:
            _dict['startDate'] = None

        # set to None if end_date (nullable) is None
        # and model_fields_set contains the field
        if self.end_date is None and "end_date" in self.model_fields_set:
            _dict['endDate'] = None

        # set to None if summary (nullable) is None
        # and model_fields_set contains the field
        if self.summary is None and "summary" in self.model_fields_set:
            _dict['summary'] = None

        # set to None if analysis_priority (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_priority is None and "analysis_priority" in self.model_fields_set:
            _dict['analysisPriority'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AnalysisV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "owner": UserIdentifier.from_dict(obj["owner"]) if obj.get("owner") is not None else None,
            "tenant": TenantIdentifier.from_dict(obj["tenant"]) if obj.get("tenant") is not None else None,
            "reference": obj.get("reference"),
            "userReference": obj.get("userReference"),
            "pipeline": PipelineV4.from_dict(obj["pipeline"]) if obj.get("pipeline") is not None else None,
            "workflowSession": WorkflowSessionV4.from_dict(obj["workflowSession"]) if obj.get("workflowSession") is not None else None,
            "status": obj.get("status"),
            "startDate": obj.get("startDate"),
            "endDate": obj.get("endDate"),
            "summary": obj.get("summary"),
            "analysisStorage": AnalysisStorageV4.from_dict(obj["analysisStorage"]) if obj.get("analysisStorage") is not None else None,
            "analysisPriority": obj.get("analysisPriority"),
            "tags": AnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None
        })
        return _obj

AnalysisV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_priority : str | None

The type of the None singleton.

var analysis_storage : AnalysisStorageV4 | None

The type of the None singleton.

var application : ApplicationV4 | None

The type of the None singleton.

var end_date : datetime.datetime | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner : UserIdentifier

The type of the None singleton.

var pipeline : PipelineV4

The type of the None singleton.

var reference : str

The type of the None singleton.

var start_date : datetime.datetime | None

The type of the None singleton.

var status : str

The type of the None singleton.

var summary : str | None

The type of the None singleton.

var tags : AnalysisTag

The type of the None singleton.

var tenant : TenantIdentifier

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var user_reference : str

The type of the None singleton.

var workflow_session : WorkflowSessionV4 | None

The type of the None singleton.

Static methods

def analysis_priority_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AnalysisV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AnalysisV4 from a JSON string

def status_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of owner
    if self.owner:
        _dict['owner'] = self.owner.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tenant
    if self.tenant:
        _dict['tenant'] = self.tenant.to_dict()
    # override the default output from pydantic by calling `to_dict()` of pipeline
    if self.pipeline:
        _dict['pipeline'] = self.pipeline.to_dict()
    # override the default output from pydantic by calling `to_dict()` of workflow_session
    if self.workflow_session:
        _dict['workflowSession'] = self.workflow_session.to_dict()
    # override the default output from pydantic by calling `to_dict()` of analysis_storage
    if self.analysis_storage:
        _dict['analysisStorage'] = self.analysis_storage.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # set to None if start_date (nullable) is None
    # and model_fields_set contains the field
    if self.start_date is None and "start_date" in self.model_fields_set:
        _dict['startDate'] = None

    # set to None if end_date (nullable) is None
    # and model_fields_set contains the field
    if self.end_date is None and "end_date" in self.model_fields_set:
        _dict['endDate'] = None

    # set to None if summary (nullable) is None
    # and model_fields_set contains the field
    if self.summary is None and "summary" in self.model_fields_set:
        _dict['summary'] = None

    # set to None if analysis_priority (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_priority is None and "analysis_priority" in self.model_fields_set:
        _dict['analysisPriority'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ApiAttributeError (msg, path_to_item=None)

Expand source code

class ApiAttributeError(OpenApiException, AttributeError):
    def __init__(self, msg, path_to_item=None) -> None:
        """
        Raised when an attribute reference or assignment fails.

        Args:
            msg (str): the exception message

        Keyword Args:
            path_to_item (None/list) the path to the exception in the
                received_data dict
        """
        self.path_to_item = path_to_item
        full_msg = msg
        if path_to_item:
            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
        super(ApiAttributeError, self).__init__(full_msg)

The base exception class for all OpenAPIExceptions

Raised when an attribute reference or assignment fails.

Args

msg : str

the exception message

Keyword Args: path_to_item (None/list) the path to the exception in the received_data dict

Ancestors

• OpenApiException
• builtins.AttributeError
• builtins.Exception
• builtins.BaseException

class ApiClient (configuration=None, header_name=None, header_value=None, cookie=None)

Expand source code

class ApiClient:
    """Generic API client for OpenAPI client library builds.

    OpenAPI generic API client. This client handles the client-
    server communication, and is invariant across implementations. Specifics of
    the methods and models for each application are generated from the OpenAPI
    templates.

    :param configuration: .Configuration object for this client
    :param header_name: a header to pass when making calls to the API.
    :param header_value: a header value to pass when making calls to
        the API.
    :param cookie: a cookie to include in the header when making calls
        to the API
    """

    PRIMITIVE_TYPES = (float, bool, bytes, str, int)
    NATIVE_TYPES_MAPPING = {
        'int': int,
        'long': int, # TODO remove as only py3 is supported?
        'float': float,
        'str': str,
        'bool': bool,
        'date': datetime.date,
        'datetime': datetime.datetime,
        'decimal': decimal.Decimal,
        'object': object,
    }
    _pool = None

    def __init__(
        self,
        configuration=None,
        header_name=None,
        header_value=None,
        cookie=None
    ) -> None:
        # use default configuration if none is provided
        if configuration is None:
            configuration = Configuration.get_default()
        self.configuration = configuration

        self.rest_client = rest.RESTClientObject(configuration)
        # FIXME set default Accept header to application/vnd.illumina.v3+json
        #  https://github.com/umccr/libica/issues/139
        self.default_headers = {
            "Accept": "application/vnd.illumina.v3+json",
        }
        if header_name is not None:
            self.default_headers[header_name] = header_value
        self.cookie = cookie
        # Set default User-Agent.
        self.user_agent = 'OpenAPI-Generator/1.0.0/python'
        self.client_side_validation = configuration.client_side_validation

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        pass

    @property
    def user_agent(self):
        """User agent for this API client"""
        return self.default_headers['User-Agent']

    @user_agent.setter
    def user_agent(self, value):
        self.default_headers['User-Agent'] = value

    def set_default_header(self, header_name, header_value):
        self.default_headers[header_name] = header_value


    _default = None

    @classmethod
    def get_default(cls):
        """Return new instance of ApiClient.

        This method returns newly created, based on default constructor,
        object of ApiClient class or returns a copy of default
        ApiClient.

        :return: The ApiClient object.
        """
        if cls._default is None:
            cls._default = ApiClient()
        return cls._default

    @classmethod
    def set_default(cls, default):
        """Set default instance of ApiClient.

        It stores default ApiClient.

        :param default: object of ApiClient.
        """
        cls._default = default

    def param_serialize(
        self,
        method,
        resource_path,
        path_params=None,
        query_params=None,
        header_params=None,
        body=None,
        post_params=None,
        files=None, auth_settings=None,
        collection_formats=None,
        _host=None,
        _request_auth=None
    ) -> RequestSerialized:

        """Builds the HTTP request params needed by the request.
        :param method: Method to call.
        :param resource_path: Path to method endpoint.
        :param path_params: Path parameters in the url.
        :param query_params: Query parameters in the url.
        :param header_params: Header parameters to be
            placed in the request header.
        :param body: Request body.
        :param post_params dict: Request post form parameters,
            for `application/x-www-form-urlencoded`, `multipart/form-data`.
        :param auth_settings list: Auth Settings names for the request.
        :param files dict: key -> filename, value -> filepath,
            for `multipart/form-data`.
        :param collection_formats: dict of collection formats for path, query,
            header, and post parameters.
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the authentication
                              in the spec for a single request.
        :return: tuple of form (path, http_method, query_params, header_params,
            body, post_params, files)
        """

        config = self.configuration

        # header parameters
        header_params = header_params or {}
        header_params.update(self.default_headers)
        if self.cookie:
            header_params['Cookie'] = self.cookie
        if header_params:
            header_params = self.sanitize_for_serialization(header_params)
            header_params = dict(
                self.parameters_to_tuples(header_params,collection_formats)
            )

        # path parameters
        if path_params:
            path_params = self.sanitize_for_serialization(path_params)
            path_params = self.parameters_to_tuples(
                path_params,
                collection_formats
            )
            for k, v in path_params:
                # specified safe chars, encode everything
                resource_path = resource_path.replace(
                    '{%s}' % k,
                    quote(str(v), safe=config.safe_chars_for_path_param)
                )

        # post parameters
        if post_params or files:
            post_params = post_params if post_params else []
            post_params = self.sanitize_for_serialization(post_params)
            post_params = self.parameters_to_tuples(
                post_params,
                collection_formats
            )
            if files:
                post_params.extend(self.files_parameters(files))

        # auth setting
        self.update_params_for_auth(
            header_params,
            query_params,
            auth_settings,
            resource_path,
            method,
            body,
            request_auth=_request_auth
        )

        # body
        if body:
            body = self.sanitize_for_serialization(body)

        # request url
        if _host is None or self.configuration.ignore_operation_servers:
            url = self.configuration.host + resource_path
        else:
            # use server/host defined in path or operation instead
            url = _host + resource_path

        # query parameters
        if query_params:
            query_params = self.sanitize_for_serialization(query_params)
            url_query = self.parameters_to_url_query(
                query_params,
                collection_formats
            )
            url += "?" + url_query

        return method, url, header_params, body, post_params


    def call_api(
        self,
        method,
        url,
        header_params=None,
        body=None,
        post_params=None,
        _request_timeout=None
    ) -> rest.RESTResponse:
        """Makes the HTTP request (synchronous)
        :param method: Method to call.
        :param url: Path to method endpoint.
        :param header_params: Header parameters to be
            placed in the request header.
        :param body: Request body.
        :param post_params dict: Request post form parameters,
            for `application/x-www-form-urlencoded`, `multipart/form-data`.
        :param _request_timeout: timeout setting for this request.
        :return: RESTResponse
        """

        try:
            # perform request and return response
            response_data = self.rest_client.request(
                method, url,
                headers=header_params,
                body=body, post_params=post_params,
                _request_timeout=_request_timeout
            )

        except ApiException as e:
            raise e

        return response_data

    def response_deserialize(
        self,
        response_data: rest.RESTResponse,
        response_types_map: Optional[Dict[str, ApiResponseT]]=None
    ) -> ApiResponse[ApiResponseT]:
        """Deserializes response into an object.
        :param response_data: RESTResponse object to be deserialized.
        :param response_types_map: dict of response types.
        :return: ApiResponse
        """

        msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
        assert response_data.data is not None, msg

        response_type = response_types_map.get(str(response_data.status), None)
        if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
            # if not found, look for '1XX', '2XX', etc.
            response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)

        # deserialize response data
        response_text = None
        return_data = None
        try:
            if response_type == "bytearray":
                return_data = response_data.data
            elif response_type == "file":
                return_data = self.__deserialize_file(response_data)
            elif response_type is not None:
                match = None
                content_type = response_data.getheader('content-type')
                if content_type is not None:
                    match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
                encoding = match.group(1) if match else "utf-8"
                response_text = response_data.data.decode(encoding)
                return_data = self.deserialize(response_text, response_type, content_type)
        finally:
            if not 200 <= response_data.status <= 299:
                raise ApiException.from_response(
                    http_resp=response_data,
                    body=response_text,
                    data=return_data,
                )

        return ApiResponse(
            status_code = response_data.status,
            data = return_data,
            headers = response_data.getheaders(),
            raw_data = response_data.data
        )

    def sanitize_for_serialization(self, obj):
        """Builds a JSON POST object.

        If obj is None, return None.
        If obj is SecretStr, return obj.get_secret_value()
        If obj is str, int, long, float, bool, return directly.
        If obj is datetime.datetime, datetime.date
            convert to string in iso8601 format.
        If obj is decimal.Decimal return string representation.
        If obj is list, sanitize each element in the list.
        If obj is dict, return the dict.
        If obj is OpenAPI model, return the properties dict.

        :param obj: The data to serialize.
        :return: The serialized form of data.
        """
        if obj is None:
            return None
        elif isinstance(obj, Enum):
            return obj.value
        elif isinstance(obj, SecretStr):
            return obj.get_secret_value()
        elif isinstance(obj, self.PRIMITIVE_TYPES):
            return obj
        elif isinstance(obj, list):
            return [
                self.sanitize_for_serialization(sub_obj) for sub_obj in obj
            ]
        elif isinstance(obj, tuple):
            return tuple(
                self.sanitize_for_serialization(sub_obj) for sub_obj in obj
            )
        elif isinstance(obj, (datetime.datetime, datetime.date)):
            return obj.isoformat()
        elif isinstance(obj, decimal.Decimal):
            return str(obj)

        elif isinstance(obj, dict):
            obj_dict = obj
        else:
            # Convert model obj to dict except
            # attributes `openapi_types`, `attribute_map`
            # and attributes which value is not None.
            # Convert attribute name to json key in
            # model definition for request.
            if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
                obj_dict = obj.to_dict()
            else:
                obj_dict = obj.__dict__

        if isinstance(obj_dict, list):
            # here we handle instances that can either be a list or something else, and only became a real list by calling to_dict()
            return self.sanitize_for_serialization(obj_dict)

        return {
            key: self.sanitize_for_serialization(val)
            for key, val in obj_dict.items()
        }

    def deserialize(self, response_text: str, response_type: str, content_type: Optional[str]):
        """Deserializes response into an object.

        :param response: RESTResponse object to be deserialized.
        :param response_type: class literal for
            deserialized object, or string of class name.
        :param content_type: content type of response.

        :return: deserialized object.
        """

        # fetch data from response object
        if content_type is None:
            try:
                data = json.loads(response_text)
            except ValueError:
                data = response_text
        elif re.match(r'^application/(json|[\w!#$&.+-^_]+\+json)\s*(;|$)', content_type, re.IGNORECASE):
            if response_text == "":
                data = ""
            else:
                data = json.loads(response_text)
        elif re.match(r'^text\/[a-z.+-]+\s*(;|$)', content_type, re.IGNORECASE):
            data = response_text
        else:
            raise ApiException(
                status=0,
                reason="Unsupported content type: {0}".format(content_type)
            )

        return self.__deserialize(data, response_type)

    def __deserialize(self, data, klass):
        """Deserializes dict, list, str into an object.

        :param data: dict, list or str.
        :param klass: class literal, or string of class name.

        :return: object.
        """
        if data is None:
            return None

        if isinstance(klass, str):
            if klass.startswith('List['):
                m = re.match(r'List\[(.*)]', klass)
                assert m is not None, "Malformed List type definition"
                sub_kls = m.group(1)
                return [self.__deserialize(sub_data, sub_kls)
                        for sub_data in data]

            if klass.startswith('Dict['):
                m = re.match(r'Dict\[([^,]*), (.*)]', klass)
                assert m is not None, "Malformed Dict type definition"
                sub_kls = m.group(2)
                return {k: self.__deserialize(v, sub_kls)
                        for k, v in data.items()}

            # convert str to class
            if klass in self.NATIVE_TYPES_MAPPING:
                klass = self.NATIVE_TYPES_MAPPING[klass]
            else:
                klass = getattr(libica.openapi.v3.models, klass)

        if klass in self.PRIMITIVE_TYPES:
            return self.__deserialize_primitive(data, klass)
        elif klass == object:
            return self.__deserialize_object(data)
        elif klass == datetime.date:
            return self.__deserialize_date(data)
        elif klass == datetime.datetime:
            return self.__deserialize_datetime(data)
        elif klass == decimal.Decimal:
            return decimal.Decimal(data)
        elif issubclass(klass, Enum):
            return self.__deserialize_enum(data, klass)
        else:
            return self.__deserialize_model(data, klass)

    def parameters_to_tuples(self, params, collection_formats):
        """Get parameters as list of tuples, formatting collections.

        :param params: Parameters as dict or list of two-tuples
        :param dict collection_formats: Parameter collection formats
        :return: Parameters as list of tuples, collections formatted
        """
        new_params: List[Tuple[str, str]] = []
        if collection_formats is None:
            collection_formats = {}
        for k, v in params.items() if isinstance(params, dict) else params:
            if k in collection_formats:
                collection_format = collection_formats[k]
                if collection_format == 'multi':
                    new_params.extend((k, value) for value in v)
                else:
                    if collection_format == 'ssv':
                        delimiter = ' '
                    elif collection_format == 'tsv':
                        delimiter = '\t'
                    elif collection_format == 'pipes':
                        delimiter = '|'
                    else:  # csv is the default
                        delimiter = ','
                    new_params.append(
                        (k, delimiter.join(str(value) for value in v)))
            else:
                new_params.append((k, v))
        return new_params

    def parameters_to_url_query(self, params, collection_formats):
        """Get parameters as list of tuples, formatting collections.

        :param params: Parameters as dict or list of two-tuples
        :param dict collection_formats: Parameter collection formats
        :return: URL query string (e.g. a=Hello%20World&b=123)
        """
        new_params: List[Tuple[str, str]] = []
        if collection_formats is None:
            collection_formats = {}
        for k, v in params.items() if isinstance(params, dict) else params:
            if isinstance(v, bool):
                v = str(v).lower()
            if isinstance(v, (int, float)):
                v = str(v)
            if isinstance(v, dict):
                v = json.dumps(v)

            if k in collection_formats:
                collection_format = collection_formats[k]
                if collection_format == 'multi':
                    new_params.extend((k, quote(str(value))) for value in v)
                else:
                    if collection_format == 'ssv':
                        delimiter = ' '
                    elif collection_format == 'tsv':
                        delimiter = '\t'
                    elif collection_format == 'pipes':
                        delimiter = '|'
                    else:  # csv is the default
                        delimiter = ','
                    new_params.append(
                        (k, delimiter.join(quote(str(value)) for value in v))
                    )
            else:
                new_params.append((k, quote(str(v))))

        return "&".join(["=".join(map(str, item)) for item in new_params])

    def files_parameters(
        self,
        files: Dict[str, Union[str, bytes, List[str], List[bytes], Tuple[str, bytes]]],
    ):
        """Builds form parameters.

        :param files: File parameters.
        :return: Form parameters with files.
        """
        params = []
        for k, v in files.items():
            if isinstance(v, str):
                with open(v, 'rb') as f:
                    filename = os.path.basename(f.name)
                    filedata = f.read()
            elif isinstance(v, bytes):
                filename = k
                filedata = v
            elif isinstance(v, tuple):
                filename, filedata = v
            elif isinstance(v, list):
                for file_param in v:
                    params.extend(self.files_parameters({k: file_param}))
                continue
            else:
                raise ValueError("Unsupported file value")
            mimetype = (
                mimetypes.guess_type(filename)[0]
                or 'application/octet-stream'
            )
            params.append(
                tuple([k, tuple([filename, filedata, mimetype])])
            )
        return params

    def select_header_accept(self, accepts: List[str]) -> Optional[str]:
        """Returns `Accept` based on an array of accepts provided.

        :param accepts: List of headers.
        :return: Accept (e.g. application/json).
        """
        if not accepts:
            return None

        for accept in accepts:
            if re.search('json', accept, re.IGNORECASE):
                return accept

        return accepts[0]

    def select_header_content_type(self, content_types):
        """Returns `Content-Type` based on an array of content_types provided.

        :param content_types: List of content-types.
        :return: Content-Type (e.g. application/json).
        """
        if not content_types:
            return None

        for content_type in content_types:
            if re.search('json', content_type, re.IGNORECASE):
                return content_type

        return content_types[0]

    def update_params_for_auth(
        self,
        headers,
        queries,
        auth_settings,
        resource_path,
        method,
        body,
        request_auth=None
    ) -> None:
        """Updates header and query params based on authentication setting.

        :param headers: Header parameters dict to be updated.
        :param queries: Query parameters tuple list to be updated.
        :param auth_settings: Authentication setting identifiers list.
        :resource_path: A string representation of the HTTP request resource path.
        :method: A string representation of the HTTP request method.
        :body: A object representing the body of the HTTP request.
        The object type is the return value of sanitize_for_serialization().
        :param request_auth: if set, the provided settings will
                             override the token in the configuration.
        """
        if not auth_settings:
            return

        if request_auth:
            self._apply_auth_params(
                headers,
                queries,
                resource_path,
                method,
                body,
                request_auth
            )
        else:
            for auth in auth_settings:
                auth_setting = self.configuration.auth_settings().get(auth)
                if auth_setting:
                    self._apply_auth_params(
                        headers,
                        queries,
                        resource_path,
                        method,
                        body,
                        auth_setting
                    )

    def _apply_auth_params(
        self,
        headers,
        queries,
        resource_path,
        method,
        body,
        auth_setting
    ) -> None:
        """Updates the request parameters based on a single auth_setting

        :param headers: Header parameters dict to be updated.
        :param queries: Query parameters tuple list to be updated.
        :resource_path: A string representation of the HTTP request resource path.
        :method: A string representation of the HTTP request method.
        :body: A object representing the body of the HTTP request.
        The object type is the return value of sanitize_for_serialization().
        :param auth_setting: auth settings for the endpoint
        """
        if auth_setting['in'] == 'cookie':
            headers['Cookie'] = auth_setting['value']
        elif auth_setting['in'] == 'header':
            if auth_setting['type'] != 'http-signature':
                headers[auth_setting['key']] = auth_setting['value']
        elif auth_setting['in'] == 'query':
            queries.append((auth_setting['key'], auth_setting['value']))
        else:
            raise ApiValueError(
                'Authentication token must be in `query` or `header`'
            )

    def __deserialize_file(self, response):
        """Deserializes body to file

        Saves response body into a file in a temporary folder,
        using the filename from the `Content-Disposition` header if provided.

        handle file downloading
        save response body into a tmp file and return the instance

        :param response:  RESTResponse.
        :return: file path.
        """
        fd, path = tempfile.mkstemp(dir=self.configuration.temp_folder_path)
        os.close(fd)
        os.remove(path)

        content_disposition = response.getheader("Content-Disposition")
        if content_disposition:
            m = re.search(
                r'filename=[\'"]?([^\'"\s]+)[\'"]?',
                content_disposition
            )
            assert m is not None, "Unexpected 'content-disposition' header value"
            filename = m.group(1)
            path = os.path.join(os.path.dirname(path), filename)

        with open(path, "wb") as f:
            f.write(response.data)

        return path

    def __deserialize_primitive(self, data, klass):
        """Deserializes string to primitive type.

        :param data: str.
        :param klass: class literal.

        :return: int, long, float, str, bool.
        """
        try:
            return klass(data)
        except UnicodeEncodeError:
            return str(data)
        except TypeError:
            return data

    def __deserialize_object(self, value):
        """Return an original value.

        :return: object.
        """
        return value

    def __deserialize_date(self, string):
        """Deserializes string to date.

        :param string: str.
        :return: date.
        """
        try:
            return parse(string).date()
        except ImportError:
            return string
        except ValueError:
            raise rest.ApiException(
                status=0,
                reason="Failed to parse `{0}` as date object".format(string)
            )

    def __deserialize_datetime(self, string):
        """Deserializes string to datetime.

        The string should be in iso8601 datetime format.

        :param string: str.
        :return: datetime.
        """
        try:
            return parse(string)
        except ImportError:
            return string
        except ValueError:
            raise rest.ApiException(
                status=0,
                reason=(
                    "Failed to parse `{0}` as datetime object"
                    .format(string)
                )
            )

    def __deserialize_enum(self, data, klass):
        """Deserializes primitive type to enum.

        :param data: primitive type.
        :param klass: class literal.
        :return: enum value.
        """
        try:
            return klass(data)
        except ValueError:
            raise rest.ApiException(
                status=0,
                reason=(
                    "Failed to parse `{0}` as `{1}`"
                    .format(data, klass)
                )
            )

    def __deserialize_model(self, data, klass):
        """Deserializes list or dict to model.

        :param data: dict, list.
        :param klass: class literal.
        :return: model object.
        """

        return klass.from_dict(data)

Generic API client for OpenAPI client library builds.

OpenAPI generic API client. This client handles the client- server communication, and is invariant across implementations. Specifics of the methods and models for each application are generated from the OpenAPI templates.

:param configuration: .Configuration object for this client :param header_name: a header to pass when making calls to the API. :param header_value: a header value to pass when making calls to the API. :param cookie: a cookie to include in the header when making calls to the API

Class variables

var NATIVE_TYPES_MAPPING

The type of the None singleton.

var PRIMITIVE_TYPES

The type of the None singleton.

Static methods

def get_default()

Return new instance of ApiClient.

This method returns newly created, based on default constructor, object of ApiClient class or returns a copy of default ApiClient.

:return: The ApiClient object.

def set_default(default)

Set default instance of ApiClient.

It stores default ApiClient.

:param default: object of ApiClient.

Instance variables

prop user_agent

Expand source code

@property
def user_agent(self):
    """User agent for this API client"""
    return self.default_headers['User-Agent']

User agent for this API client

Methods

def call_api(self, method, url, header_params=None, body=None, post_params=None) ‑> RESTResponse

Expand source code

def call_api(
    self,
    method,
    url,
    header_params=None,
    body=None,
    post_params=None,
    _request_timeout=None
) -> rest.RESTResponse:
    """Makes the HTTP request (synchronous)
    :param method: Method to call.
    :param url: Path to method endpoint.
    :param header_params: Header parameters to be
        placed in the request header.
    :param body: Request body.
    :param post_params dict: Request post form parameters,
        for `application/x-www-form-urlencoded`, `multipart/form-data`.
    :param _request_timeout: timeout setting for this request.
    :return: RESTResponse
    """

    try:
        # perform request and return response
        response_data = self.rest_client.request(
            method, url,
            headers=header_params,
            body=body, post_params=post_params,
            _request_timeout=_request_timeout
        )

    except ApiException as e:
        raise e

    return response_data

Makes the HTTP request (synchronous) :param method: Method to call. :param url: Path to method endpoint. :param header_params: Header parameters to be placed in the request header. :param body: Request body. :param post_params dict: Request post form parameters, for application/x-www-form-urlencoded, multipart/form-data. :param _request_timeout: timeout setting for this request. :return: RESTResponse

def deserialize(self, response_text: str, response_type: str, content_type: str | None)

Expand source code

def deserialize(self, response_text: str, response_type: str, content_type: Optional[str]):
    """Deserializes response into an object.

    :param response: RESTResponse object to be deserialized.
    :param response_type: class literal for
        deserialized object, or string of class name.
    :param content_type: content type of response.

    :return: deserialized object.
    """

    # fetch data from response object
    if content_type is None:
        try:
            data = json.loads(response_text)
        except ValueError:
            data = response_text
    elif re.match(r'^application/(json|[\w!#$&.+-^_]+\+json)\s*(;|$)', content_type, re.IGNORECASE):
        if response_text == "":
            data = ""
        else:
            data = json.loads(response_text)
    elif re.match(r'^text\/[a-z.+-]+\s*(;|$)', content_type, re.IGNORECASE):
        data = response_text
    else:
        raise ApiException(
            status=0,
            reason="Unsupported content type: {0}".format(content_type)
        )

    return self.__deserialize(data, response_type)

Deserializes response into an object.

:param response: RESTResponse object to be deserialized. :param response_type: class literal for deserialized object, or string of class name. :param content_type: content type of response.

:return: deserialized object.

def files_parameters(self,
files: Dict[str, str | bytes | List[str] | List[bytes] | Tuple[str, bytes]])

Expand source code

def files_parameters(
    self,
    files: Dict[str, Union[str, bytes, List[str], List[bytes], Tuple[str, bytes]]],
):
    """Builds form parameters.

    :param files: File parameters.
    :return: Form parameters with files.
    """
    params = []
    for k, v in files.items():
        if isinstance(v, str):
            with open(v, 'rb') as f:
                filename = os.path.basename(f.name)
                filedata = f.read()
        elif isinstance(v, bytes):
            filename = k
            filedata = v
        elif isinstance(v, tuple):
            filename, filedata = v
        elif isinstance(v, list):
            for file_param in v:
                params.extend(self.files_parameters({k: file_param}))
            continue
        else:
            raise ValueError("Unsupported file value")
        mimetype = (
            mimetypes.guess_type(filename)[0]
            or 'application/octet-stream'
        )
        params.append(
            tuple([k, tuple([filename, filedata, mimetype])])
        )
    return params

Builds form parameters.

:param files: File parameters. :return: Form parameters with files.

def param_serialize(self,
method,
resource_path,
path_params=None,
query_params=None,
header_params=None,
body=None,
post_params=None,
files=None,
auth_settings=None,
collection_formats=None) ‑> Tuple[str, str, Dict[str, str], str | None, List[str]]

Expand source code

def param_serialize(
    self,
    method,
    resource_path,
    path_params=None,
    query_params=None,
    header_params=None,
    body=None,
    post_params=None,
    files=None, auth_settings=None,
    collection_formats=None,
    _host=None,
    _request_auth=None
) -> RequestSerialized:

    """Builds the HTTP request params needed by the request.
    :param method: Method to call.
    :param resource_path: Path to method endpoint.
    :param path_params: Path parameters in the url.
    :param query_params: Query parameters in the url.
    :param header_params: Header parameters to be
        placed in the request header.
    :param body: Request body.
    :param post_params dict: Request post form parameters,
        for `application/x-www-form-urlencoded`, `multipart/form-data`.
    :param auth_settings list: Auth Settings names for the request.
    :param files dict: key -> filename, value -> filepath,
        for `multipart/form-data`.
    :param collection_formats: dict of collection formats for path, query,
        header, and post parameters.
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the authentication
                          in the spec for a single request.
    :return: tuple of form (path, http_method, query_params, header_params,
        body, post_params, files)
    """

    config = self.configuration

    # header parameters
    header_params = header_params or {}
    header_params.update(self.default_headers)
    if self.cookie:
        header_params['Cookie'] = self.cookie
    if header_params:
        header_params = self.sanitize_for_serialization(header_params)
        header_params = dict(
            self.parameters_to_tuples(header_params,collection_formats)
        )

    # path parameters
    if path_params:
        path_params = self.sanitize_for_serialization(path_params)
        path_params = self.parameters_to_tuples(
            path_params,
            collection_formats
        )
        for k, v in path_params:
            # specified safe chars, encode everything
            resource_path = resource_path.replace(
                '{%s}' % k,
                quote(str(v), safe=config.safe_chars_for_path_param)
            )

    # post parameters
    if post_params or files:
        post_params = post_params if post_params else []
        post_params = self.sanitize_for_serialization(post_params)
        post_params = self.parameters_to_tuples(
            post_params,
            collection_formats
        )
        if files:
            post_params.extend(self.files_parameters(files))

    # auth setting
    self.update_params_for_auth(
        header_params,
        query_params,
        auth_settings,
        resource_path,
        method,
        body,
        request_auth=_request_auth
    )

    # body
    if body:
        body = self.sanitize_for_serialization(body)

    # request url
    if _host is None or self.configuration.ignore_operation_servers:
        url = self.configuration.host + resource_path
    else:
        # use server/host defined in path or operation instead
        url = _host + resource_path

    # query parameters
    if query_params:
        query_params = self.sanitize_for_serialization(query_params)
        url_query = self.parameters_to_url_query(
            query_params,
            collection_formats
        )
        url += "?" + url_query

    return method, url, header_params, body, post_params

Builds the HTTP request params needed by the request. :param method: Method to call. :param resource_path: Path to method endpoint. :param path_params: Path parameters in the url. :param query_params: Query parameters in the url. :param header_params: Header parameters to be placed in the request header. :param body: Request body. :param post_params dict: Request post form parameters, for application/x-www-form-urlencoded, multipart/form-data. :param auth_settings list: Auth Settings names for the request. :param files dict: key -> filename, value -> filepath, for multipart/form-data. :param collection_formats: dict of collection formats for path, query, header, and post parameters. :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :return: tuple of form (path, http_method, query_params, header_params, body, post_params, files)

def parameters_to_tuples(self, params, collection_formats)

Expand source code

def parameters_to_tuples(self, params, collection_formats):
    """Get parameters as list of tuples, formatting collections.

    :param params: Parameters as dict or list of two-tuples
    :param dict collection_formats: Parameter collection formats
    :return: Parameters as list of tuples, collections formatted
    """
    new_params: List[Tuple[str, str]] = []
    if collection_formats is None:
        collection_formats = {}
    for k, v in params.items() if isinstance(params, dict) else params:
        if k in collection_formats:
            collection_format = collection_formats[k]
            if collection_format == 'multi':
                new_params.extend((k, value) for value in v)
            else:
                if collection_format == 'ssv':
                    delimiter = ' '
                elif collection_format == 'tsv':
                    delimiter = '\t'
                elif collection_format == 'pipes':
                    delimiter = '|'
                else:  # csv is the default
                    delimiter = ','
                new_params.append(
                    (k, delimiter.join(str(value) for value in v)))
        else:
            new_params.append((k, v))
    return new_params

Get parameters as list of tuples, formatting collections.

:param params: Parameters as dict or list of two-tuples :param dict collection_formats: Parameter collection formats :return: Parameters as list of tuples, collections formatted

def parameters_to_url_query(self, params, collection_formats)

Expand source code

def parameters_to_url_query(self, params, collection_formats):
    """Get parameters as list of tuples, formatting collections.

    :param params: Parameters as dict or list of two-tuples
    :param dict collection_formats: Parameter collection formats
    :return: URL query string (e.g. a=Hello%20World&b=123)
    """
    new_params: List[Tuple[str, str]] = []
    if collection_formats is None:
        collection_formats = {}
    for k, v in params.items() if isinstance(params, dict) else params:
        if isinstance(v, bool):
            v = str(v).lower()
        if isinstance(v, (int, float)):
            v = str(v)
        if isinstance(v, dict):
            v = json.dumps(v)

        if k in collection_formats:
            collection_format = collection_formats[k]
            if collection_format == 'multi':
                new_params.extend((k, quote(str(value))) for value in v)
            else:
                if collection_format == 'ssv':
                    delimiter = ' '
                elif collection_format == 'tsv':
                    delimiter = '\t'
                elif collection_format == 'pipes':
                    delimiter = '|'
                else:  # csv is the default
                    delimiter = ','
                new_params.append(
                    (k, delimiter.join(quote(str(value)) for value in v))
                )
        else:
            new_params.append((k, quote(str(v))))

    return "&".join(["=".join(map(str, item)) for item in new_params])

Get parameters as list of tuples, formatting collections.

:param params: Parameters as dict or list of two-tuples :param dict collection_formats: Parameter collection formats :return: URL query string (e.g. a=Hello%20World&b=123)

def response_deserialize(self,
response_data: RESTResponse,
response_types_map: Dict[str, ~T] | None = None) ‑> ApiResponse

Expand source code

def response_deserialize(
    self,
    response_data: rest.RESTResponse,
    response_types_map: Optional[Dict[str, ApiResponseT]]=None
) -> ApiResponse[ApiResponseT]:
    """Deserializes response into an object.
    :param response_data: RESTResponse object to be deserialized.
    :param response_types_map: dict of response types.
    :return: ApiResponse
    """

    msg = "RESTResponse.read() must be called before passing it to response_deserialize()"
    assert response_data.data is not None, msg

    response_type = response_types_map.get(str(response_data.status), None)
    if not response_type and isinstance(response_data.status, int) and 100 <= response_data.status <= 599:
        # if not found, look for '1XX', '2XX', etc.
        response_type = response_types_map.get(str(response_data.status)[0] + "XX", None)

    # deserialize response data
    response_text = None
    return_data = None
    try:
        if response_type == "bytearray":
            return_data = response_data.data
        elif response_type == "file":
            return_data = self.__deserialize_file(response_data)
        elif response_type is not None:
            match = None
            content_type = response_data.getheader('content-type')
            if content_type is not None:
                match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
            encoding = match.group(1) if match else "utf-8"
            response_text = response_data.data.decode(encoding)
            return_data = self.deserialize(response_text, response_type, content_type)
    finally:
        if not 200 <= response_data.status <= 299:
            raise ApiException.from_response(
                http_resp=response_data,
                body=response_text,
                data=return_data,
            )

    return ApiResponse(
        status_code = response_data.status,
        data = return_data,
        headers = response_data.getheaders(),
        raw_data = response_data.data
    )

Deserializes response into an object. :param response_data: RESTResponse object to be deserialized. :param response_types_map: dict of response types. :return: ApiResponse

def sanitize_for_serialization(self, obj)

Expand source code

def sanitize_for_serialization(self, obj):
    """Builds a JSON POST object.

    If obj is None, return None.
    If obj is SecretStr, return obj.get_secret_value()
    If obj is str, int, long, float, bool, return directly.
    If obj is datetime.datetime, datetime.date
        convert to string in iso8601 format.
    If obj is decimal.Decimal return string representation.
    If obj is list, sanitize each element in the list.
    If obj is dict, return the dict.
    If obj is OpenAPI model, return the properties dict.

    :param obj: The data to serialize.
    :return: The serialized form of data.
    """
    if obj is None:
        return None
    elif isinstance(obj, Enum):
        return obj.value
    elif isinstance(obj, SecretStr):
        return obj.get_secret_value()
    elif isinstance(obj, self.PRIMITIVE_TYPES):
        return obj
    elif isinstance(obj, list):
        return [
            self.sanitize_for_serialization(sub_obj) for sub_obj in obj
        ]
    elif isinstance(obj, tuple):
        return tuple(
            self.sanitize_for_serialization(sub_obj) for sub_obj in obj
        )
    elif isinstance(obj, (datetime.datetime, datetime.date)):
        return obj.isoformat()
    elif isinstance(obj, decimal.Decimal):
        return str(obj)

    elif isinstance(obj, dict):
        obj_dict = obj
    else:
        # Convert model obj to dict except
        # attributes `openapi_types`, `attribute_map`
        # and attributes which value is not None.
        # Convert attribute name to json key in
        # model definition for request.
        if hasattr(obj, 'to_dict') and callable(getattr(obj, 'to_dict')):
            obj_dict = obj.to_dict()
        else:
            obj_dict = obj.__dict__

    if isinstance(obj_dict, list):
        # here we handle instances that can either be a list or something else, and only became a real list by calling to_dict()
        return self.sanitize_for_serialization(obj_dict)

    return {
        key: self.sanitize_for_serialization(val)
        for key, val in obj_dict.items()
    }

Builds a JSON POST object.

If obj is None, return None. If obj is SecretStr, return obj.get_secret_value() If obj is str, int, long, float, bool, return directly. If obj is datetime.datetime, datetime.date convert to string in iso8601 format. If obj is decimal.Decimal return string representation. If obj is list, sanitize each element in the list. If obj is dict, return the dict. If obj is OpenAPI model, return the properties dict.

:param obj: The data to serialize. :return: The serialized form of data.

def select_header_accept(self, accepts: List[str]) ‑> str | None

Expand source code

def select_header_accept(self, accepts: List[str]) -> Optional[str]:
    """Returns `Accept` based on an array of accepts provided.

    :param accepts: List of headers.
    :return: Accept (e.g. application/json).
    """
    if not accepts:
        return None

    for accept in accepts:
        if re.search('json', accept, re.IGNORECASE):
            return accept

    return accepts[0]

Returns Accept based on an array of accepts provided.

:param accepts: List of headers. :return: Accept (e.g. application/json).

def select_header_content_type(self, content_types)

Expand source code

def select_header_content_type(self, content_types):
    """Returns `Content-Type` based on an array of content_types provided.

    :param content_types: List of content-types.
    :return: Content-Type (e.g. application/json).
    """
    if not content_types:
        return None

    for content_type in content_types:
        if re.search('json', content_type, re.IGNORECASE):
            return content_type

    return content_types[0]

Returns Content-Type based on an array of content_types provided.

:param content_types: List of content-types. :return: Content-Type (e.g. application/json).

def set_default_header(self, header_name, header_value)

Expand source code

def set_default_header(self, header_name, header_value):
    self.default_headers[header_name] = header_value

def update_params_for_auth(self, headers, queries, auth_settings, resource_path, method, body, request_auth=None) ‑> None

Expand source code

def update_params_for_auth(
    self,
    headers,
    queries,
    auth_settings,
    resource_path,
    method,
    body,
    request_auth=None
) -> None:
    """Updates header and query params based on authentication setting.

    :param headers: Header parameters dict to be updated.
    :param queries: Query parameters tuple list to be updated.
    :param auth_settings: Authentication setting identifiers list.
    :resource_path: A string representation of the HTTP request resource path.
    :method: A string representation of the HTTP request method.
    :body: A object representing the body of the HTTP request.
    The object type is the return value of sanitize_for_serialization().
    :param request_auth: if set, the provided settings will
                         override the token in the configuration.
    """
    if not auth_settings:
        return

    if request_auth:
        self._apply_auth_params(
            headers,
            queries,
            resource_path,
            method,
            body,
            request_auth
        )
    else:
        for auth in auth_settings:
            auth_setting = self.configuration.auth_settings().get(auth)
            if auth_setting:
                self._apply_auth_params(
                    headers,
                    queries,
                    resource_path,
                    method,
                    body,
                    auth_setting
                )

Updates header and query params based on authentication setting.

:param headers: Header parameters dict to be updated. :param queries: Query parameters tuple list to be updated. :param auth_settings: Authentication setting identifiers list. :resource_path: A string representation of the HTTP request resource path. :method: A string representation of the HTTP request method. :body: A object representing the body of the HTTP request. The object type is the return value of sanitize_for_serialization(). :param request_auth: if set, the provided settings will override the token in the configuration.

class ApiException (status=None,
reason=None,
http_resp=None,
*,
body: str | None = None,
data: Any | None = None)

Expand source code

class ApiException(OpenApiException):

    def __init__(
        self, 
        status=None, 
        reason=None, 
        http_resp=None,
        *,
        body: Optional[str] = None,
        data: Optional[Any] = None,
    ) -> None:
        self.status = status
        self.reason = reason
        self.body = body
        self.data = data
        self.headers = None

        if http_resp:
            if self.status is None:
                self.status = http_resp.status
            if self.reason is None:
                self.reason = http_resp.reason
            if self.body is None:
                try:
                    self.body = http_resp.data.decode('utf-8')
                except Exception:
                    pass
            self.headers = http_resp.getheaders()

    @classmethod
    def from_response(
        cls, 
        *, 
        http_resp, 
        body: Optional[str], 
        data: Optional[Any],
    ) -> Self:
        if http_resp.status == 400:
            raise BadRequestException(http_resp=http_resp, body=body, data=data)

        if http_resp.status == 401:
            raise UnauthorizedException(http_resp=http_resp, body=body, data=data)

        if http_resp.status == 403:
            raise ForbiddenException(http_resp=http_resp, body=body, data=data)

        if http_resp.status == 404:
            raise NotFoundException(http_resp=http_resp, body=body, data=data)

        # Added new conditions for 409 and 422
        if http_resp.status == 409:
            raise ConflictException(http_resp=http_resp, body=body, data=data)

        if http_resp.status == 422:
            raise UnprocessableEntityException(http_resp=http_resp, body=body, data=data)

        if 500 <= http_resp.status <= 599:
            raise ServiceException(http_resp=http_resp, body=body, data=data)
        raise ApiException(http_resp=http_resp, body=body, data=data)

    def __str__(self):
        """Custom error messages for exception"""
        error_message = "({0})\n"\
                        "Reason: {1}\n".format(self.status, self.reason)
        if self.headers:
            error_message += "HTTP response headers: {0}\n".format(
                self.headers)

        if self.data or self.body:
            error_message += "HTTP response body: {0}\n".format(self.data or self.body)

        return error_message

The base exception class for all OpenAPIExceptions

Ancestors

• OpenApiException
• builtins.Exception
• builtins.BaseException

Subclasses

• BadRequestException
• ConflictException
• ForbiddenException
• NotFoundException
• ServiceException
• UnauthorizedException
• UnprocessableEntityException

Static methods

def from_response(*, http_resp, body: str | None, data: Any | None) ‑> Self

class ApiKeyError (msg, path_to_item=None)

Expand source code

class ApiKeyError(OpenApiException, KeyError):
    def __init__(self, msg, path_to_item=None) -> None:
        """
        Args:
            msg (str): the exception message

        Keyword Args:
            path_to_item (None/list) the path to the exception in the
                received_data dict
        """
        self.path_to_item = path_to_item
        full_msg = msg
        if path_to_item:
            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
        super(ApiKeyError, self).__init__(full_msg)

The base exception class for all OpenAPIExceptions

Args

msg : str

the exception message

Keyword Args: path_to_item (None/list) the path to the exception in the received_data dict

Ancestors

• OpenApiException
• builtins.KeyError
• builtins.LookupError
• builtins.Exception
• builtins.BaseException

class ApiResponse (**data: Any)

Expand source code

class ApiResponse(BaseModel, Generic[T]):
    """
    API response object
    """

    status_code: StrictInt = Field(description="HTTP status code")
    headers: Optional[Mapping[str, str]] = Field(None, description="HTTP headers")
    data: T = Field(description="Deserialized data given the data type")
    raw_data: StrictBytes = Field(description="Raw data (HTTP response body)")

    model_config = {
        "arbitrary_types_allowed": True
    }

API response object

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel
• typing.Generic

Subclasses

• libica.openapi.v3.api_response.ApiResponse[ActivationCodeDetailList]
• libica.openapi.v3.api_response.ApiResponse[ActivationCodeDetail]
• libica.openapi.v3.api_response.ApiResponse[AnalysisCreationBatchItemPagedListV4]
• libica.openapi.v3.api_response.ApiResponse[AnalysisCreationBatchItemV4]
• libica.openapi.v3.api_response.ApiResponse[AnalysisCreationBatch]
• libica.openapi.v3.api_response.ApiResponse[AnalysisInputList]
• libica.openapi.v3.api_response.ApiResponse[AnalysisOutputList]
• libica.openapi.v3.api_response.ApiResponse[AnalysisPagedListV3]
• libica.openapi.v3.api_response.ApiResponse[AnalysisPagedListV4]
• libica.openapi.v3.api_response.ApiResponse[AnalysisRawOutput]
• libica.openapi.v3.api_response.ApiResponse[AnalysisReportEntryList]
• libica.openapi.v3.api_response.ApiResponse[AnalysisStepList]
• libica.openapi.v3.api_response.ApiResponse[AnalysisStorageListV3]
• libica.openapi.v3.api_response.ApiResponse[AnalysisStorageListV4]
• libica.openapi.v3.api_response.ApiResponse[AnalysisUsageDetails]
• libica.openapi.v3.api_response.ApiResponse[AnalysisV4]
• libica.openapi.v3.api_response.ApiResponse[BaseConnection]
• libica.openapi.v3.api_response.ApiResponse[BaseJobList]
• libica.openapi.v3.api_response.ApiResponse[BaseJob]
• libica.openapi.v3.api_response.ApiResponse[BundleDataLinkingBatchItemPagedList]
• libica.openapi.v3.api_response.ApiResponse[BundleDataLinkingBatchItem]
• libica.openapi.v3.api_response.ApiResponse[BundleDataLinkingBatch]
• libica.openapi.v3.api_response.ApiResponse[BundleDataPagedList]
• libica.openapi.v3.api_response.ApiResponse[BundleDataUnlinkingBatchItemPagedList]
• libica.openapi.v3.api_response.ApiResponse[BundleDataUnlinkingBatchItem]
• libica.openapi.v3.api_response.ApiResponse[BundleDataUnlinkingBatch]
• libica.openapi.v3.api_response.ApiResponse[BundlePagedList]
• libica.openapi.v3.api_response.ApiResponse[BundlePipelineList]
• libica.openapi.v3.api_response.ApiResponse[BundleSamplePagedList]
• libica.openapi.v3.api_response.ApiResponse[BundleToolsList]
• libica.openapi.v3.api_response.ApiResponse[Bundle]
• libica.openapi.v3.api_response.ApiResponse[ConnectorList]
• libica.openapi.v3.api_response.ApiResponse[Connector]
• libica.openapi.v3.api_response.ApiResponse[CustomNotificationSubscriptionList]
• libica.openapi.v3.api_response.ApiResponse[CustomNotificationSubscription]
• libica.openapi.v3.api_response.ApiResponse[CwlAnalysisInputJson]
• libica.openapi.v3.api_response.ApiResponse[CwlAnalysisOutputJson]
• libica.openapi.v3.api_response.ApiResponse[CwlToolDefinitionList]
• libica.openapi.v3.api_response.ApiResponse[DataFormatPagedList]
• libica.openapi.v3.api_response.ApiResponse[DataList]
• libica.openapi.v3.api_response.ApiResponse[DataPagedList]
• libica.openapi.v3.api_response.ApiResponse[DataTransferPagedList]
• libica.openapi.v3.api_response.ApiResponse[DataTransfer]
• libica.openapi.v3.api_response.ApiResponse[DataUrlWithPathList]
• libica.openapi.v3.api_response.ApiResponse[Data]
• libica.openapi.v3.api_response.ApiResponse[DockerImageList]
• libica.openapi.v3.api_response.ApiResponse[DockerImage]
• libica.openapi.v3.api_response.ApiResponse[DownloadRuleList]
• libica.openapi.v3.api_response.ApiResponse[DownloadRule]
• libica.openapi.v3.api_response.ApiResponse[Download]
• libica.openapi.v3.api_response.ApiResponse[EventCodeList]
• libica.openapi.v3.api_response.ApiResponse[EventLogListV3]
• libica.openapi.v3.api_response.ApiResponse[EventLogPagedListV4]
• libica.openapi.v3.api_response.ApiResponse[ExecutionConfigurationList]
• libica.openapi.v3.api_response.ApiResponse[FieldList]
• libica.openapi.v3.api_response.ApiResponse[FolderUploadSession]
• libica.openapi.v3.api_response.ApiResponse[InlineView]
• libica.openapi.v3.api_response.ApiResponse[InputFormFieldList]
• libica.openapi.v3.api_response.ApiResponse[InputParameterList]
• libica.openapi.v3.api_response.ApiResponse[JobPagedList]
• libica.openapi.v3.api_response.ApiResponse[Job]
• libica.openapi.v3.api_response.ApiResponse[MetadataModelList]
• libica.openapi.v3.api_response.ApiResponse[MetadataModel]
• libica.openapi.v3.api_response.ApiResponse[ModelField]
• libica.openapi.v3.api_response.ApiResponse[Model]
• libica.openapi.v3.api_response.ApiResponse[NoneType]
• libica.openapi.v3.api_response.ApiResponse[NotificationChannelList]
• libica.openapi.v3.api_response.ApiResponse[NotificationChannel]
• libica.openapi.v3.api_response.ApiResponse[NotificationSubscriptionList]
• libica.openapi.v3.api_response.ApiResponse[NotificationSubscription]
• libica.openapi.v3.api_response.ApiResponse[PipelineConfigurationParameterList]
• libica.openapi.v3.api_response.ApiResponse[PipelineFileList]
• libica.openapi.v3.api_response.ApiResponse[PipelineFile]
• libica.openapi.v3.api_response.ApiResponse[PipelineHtmlDocumentation]
• libica.openapi.v3.api_response.ApiResponse[PipelineLanguageVersionList]
• libica.openapi.v3.api_response.ApiResponse[PipelineList]
• libica.openapi.v3.api_response.ApiResponse[PipelineV4]
• libica.openapi.v3.api_response.ApiResponse[ProjectBaseTableList]
• libica.openapi.v3.api_response.ApiResponse[ProjectBundleList]
• libica.openapi.v3.api_response.ApiResponse[ProjectBundle]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataAndTemporaryCredentials]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataCopyBatchItemPagedList]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataCopyBatchItem]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataCopyBatch]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataLinkingBatchItemPagedListV4]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataLinkingBatchItemV4]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataLinkingBatch]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataMoveBatchItemPagedList]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataMoveBatchItem]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataMoveBatch]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataPagedList]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataUnlinkingBatchItemPagedList]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataUnlinkingBatchItem]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataUnlinkingBatch]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataUpdateBatchItemPagedList]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataUpdateBatchItem]
• libica.openapi.v3.api_response.ApiResponse[ProjectDataUpdateBatch]
• libica.openapi.v3.api_response.ApiResponse[ProjectData]
• libica.openapi.v3.api_response.ApiResponse[ProjectFileAndUploadUrl]
• libica.openapi.v3.api_response.ApiResponse[ProjectFolderAndUploadSession]
• libica.openapi.v3.api_response.ApiResponse[ProjectList]
• libica.openapi.v3.api_response.ApiResponse[ProjectPagedList]
• libica.openapi.v3.api_response.ApiResponse[ProjectPermissionListV4]
• libica.openapi.v3.api_response.ApiResponse[ProjectPermissionV4]
• libica.openapi.v3.api_response.ApiResponse[ProjectPipelineList]
• libica.openapi.v3.api_response.ApiResponse[ProjectPipelineV4]
• libica.openapi.v3.api_response.ApiResponse[ProjectPipeline]
• libica.openapi.v3.api_response.ApiResponse[ProjectSamplePagedList]
• libica.openapi.v3.api_response.ApiResponse[ProjectSample]
• libica.openapi.v3.api_response.ApiResponse[Project]
• libica.openapi.v3.api_response.ApiResponse[ReferenceSetList]
• libica.openapi.v3.api_response.ApiResponse[RegionList]
• libica.openapi.v3.api_response.ApiResponse[Region]
• libica.openapi.v3.api_response.ApiResponse[SampleCreationBatchItemPagedList]
• libica.openapi.v3.api_response.ApiResponse[SampleCreationBatchSampleItem]
• libica.openapi.v3.api_response.ApiResponse[SampleCreationBatch]
• libica.openapi.v3.api_response.ApiResponse[SampleHistoryList]
• libica.openapi.v3.api_response.ApiResponse[SamplePagedList]
• libica.openapi.v3.api_response.ApiResponse[Sample]
• libica.openapi.v3.api_response.ApiResponse[SequencingRun]
• libica.openapi.v3.api_response.ApiResponse[SpeciesList]
• libica.openapi.v3.api_response.ApiResponse[StorageBundleList]
• libica.openapi.v3.api_response.ApiResponse[StorageConfigurationDetails]
• libica.openapi.v3.api_response.ApiResponse[StorageConfigurationWithDetailsList]
• libica.openapi.v3.api_response.ApiResponse[StorageConfiguration]
• libica.openapi.v3.api_response.ApiResponse[StorageCredentialList]
• libica.openapi.v3.api_response.ApiResponse[StorageCredential]
• libica.openapi.v3.api_response.ApiResponse[SystemInfo]
• libica.openapi.v3.api_response.ApiResponse[TempCredentials]
• libica.openapi.v3.api_response.ApiResponse[TermsOfUseAcceptance]
• libica.openapi.v3.api_response.ApiResponse[TermsOfUse]
• libica.openapi.v3.api_response.ApiResponse[Token]
• libica.openapi.v3.api_response.ApiResponse[UploadRuleList]
• libica.openapi.v3.api_response.ApiResponse[UploadRule]
• libica.openapi.v3.api_response.ApiResponse[Upload]
• libica.openapi.v3.api_response.ApiResponse[UserList]
• libica.openapi.v3.api_response.ApiResponse[User]
• libica.openapi.v3.api_response.ApiResponse[WorkflowSessionAnalysisPagedListV4]
• libica.openapi.v3.api_response.ApiResponse[WorkflowSessionConfigurationList]
• libica.openapi.v3.api_response.ApiResponse[WorkflowSessionInputList]
• libica.openapi.v3.api_response.ApiResponse[WorkflowSessionPagedListV3]
• libica.openapi.v3.api_response.ApiResponse[WorkflowSessionPagedListV4]
• libica.openapi.v3.api_response.ApiResponse[WorkgroupList]
• libica.openapi.v3.api_response.ApiResponse[Workgroup]
• libica.openapi.v3.api_response.ApiResponse[bytearray]

Class variables

var data : ~T

The type of the None singleton.

var headers : Mapping[str, str] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var raw_data : bytes

The type of the None singleton.

var status_code : int

The type of the None singleton.

class ApiTypeError (msg, path_to_item=None, valid_classes=None, key_type=None)

Expand source code

class ApiTypeError(OpenApiException, TypeError):
    def __init__(self, msg, path_to_item=None, valid_classes=None,
                 key_type=None) -> None:
        """ Raises an exception for TypeErrors

        Args:
            msg (str): the exception message

        Keyword Args:
            path_to_item (list): a list of keys an indices to get to the
                                 current_item
                                 None if unset
            valid_classes (tuple): the primitive classes that current item
                                   should be an instance of
                                   None if unset
            key_type (bool): False if our value is a value in a dict
                             True if it is a key in a dict
                             False if our item is an item in a list
                             None if unset
        """
        self.path_to_item = path_to_item
        self.valid_classes = valid_classes
        self.key_type = key_type
        full_msg = msg
        if path_to_item:
            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
        super(ApiTypeError, self).__init__(full_msg)

The base exception class for all OpenAPIExceptions

Raises an exception for TypeErrors

Args

msg : str

the exception message

Keyword Args: path_to_item (list): a list of keys an indices to get to the current_item None if unset valid_classes (tuple): the primitive classes that current item should be an instance of None if unset key_type (bool): False if our value is a value in a dict True if it is a key in a dict False if our item is an item in a list None if unset

Ancestors

• OpenApiException
• builtins.TypeError
• builtins.Exception
• builtins.BaseException

class ApiValueError (msg, path_to_item=None)

Expand source code

class ApiValueError(OpenApiException, ValueError):
    def __init__(self, msg, path_to_item=None) -> None:
        """
        Args:
            msg (str): the exception message

        Keyword Args:
            path_to_item (list) the path to the exception in the
                received_data dict. None if unset
        """

        self.path_to_item = path_to_item
        full_msg = msg
        if path_to_item:
            full_msg = "{0} at {1}".format(msg, render_path(path_to_item))
        super(ApiValueError, self).__init__(full_msg)

The base exception class for all OpenAPIExceptions

Args

msg : str

the exception message

Keyword Args: path_to_item (list) the path to the exception in the received_data dict. None if unset

Ancestors

• OpenApiException
• builtins.ValueError
• builtins.Exception
• builtins.BaseException

class Application (**data: Any)

Expand source code

class Application(BaseModel):
    """
    Application
    """ # noqa: E501
    id: StrictStr
    name: StrictStr = Field(description="The unique name identifying the application")
    type: StrictStr = Field(description="The type of the application")
    display_name: Optional[StrictStr] = Field(default=None, description="The display name of the application", alias="displayName")
    __properties: ClassVar[List[str]] = ["id", "name", "type", "displayName"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['MAIN', 'WEBSOLUTION', 'EXTERNAL']):
            raise ValueError("must be one of enum values ('MAIN', 'WEBSOLUTION', 'EXTERNAL')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Application from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if display_name (nullable) is None
        # and model_fields_set contains the field
        if self.display_name is None and "display_name" in self.model_fields_set:
            _dict['displayName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Application from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name"),
            "type": obj.get("type"),
            "displayName": obj.get("displayName")
        })
        return _obj

Application

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var display_name : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Application from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Application from a JSON string

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if display_name (nullable) is None
    # and model_fields_set contains the field
    if self.display_name is None and "display_name" in self.model_fields_set:
        _dict['displayName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ApplicationV4 (**data: Any)

Expand source code

class ApplicationV4(BaseModel):
    """
    ApplicationV4
    """ # noqa: E501
    id: StrictStr
    name: StrictStr
    __properties: ClassVar[List[str]] = ["id", "name"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ApplicationV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ApplicationV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name")
        })
        return _obj

ApplicationV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ApplicationV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ApplicationV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AwsCredentials (**data: Any)

Expand source code

class AwsCredentials(BaseModel):
    """
    AwsCredentials
    """ # noqa: E501
    access_key_id: Annotated[str, Field(min_length=1, strict=True, max_length=100)] = Field(description="The access key found in aws console", alias="accessKeyId")
    secret_access_key: Annotated[str, Field(min_length=1, strict=True, max_length=100)] = Field(description="The secret access key found in aws console", alias="secretAccessKey")
    __properties: ClassVar[List[str]] = ["accessKeyId", "secretAccessKey"]

    @field_validator('access_key_id')
    def access_key_id_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"[^=,]*", value):
            raise ValueError(r"must validate the regular expression /[^=,]*/")
        return value

    @field_validator('secret_access_key')
    def secret_access_key_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"[^=,]*", value):
            raise ValueError(r"must validate the regular expression /[^=,]*/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AwsCredentials from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AwsCredentials from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "accessKeyId": obj.get("accessKeyId"),
            "secretAccessKey": obj.get("secretAccessKey")
        })
        return _obj

AwsCredentials

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var access_key_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var secret_access_key : str

The type of the None singleton.

Static methods

def access_key_id_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AwsCredentials from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AwsCredentials from a JSON string

def secret_access_key_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class AwsTempCredentials (**data: Any)

Expand source code

class AwsTempCredentials(BaseModel):
    """
    AwsTempCredentials
    """ # noqa: E501
    access_key: StrictStr = Field(description="The S3 access key.", alias="accessKey")
    secret_key: StrictStr = Field(description="The S3 secret key.", alias="secretKey")
    session_token: StrictStr = Field(description="The S3 session token.", alias="sessionToken")
    region: StrictStr = Field(description="The S3 region.")
    bucket: StrictStr = Field(description="The S3 bucket name.")
    object_prefix: StrictStr = Field(description="The S3 object prefix these temporary credentials will give access to.", alias="objectPrefix")
    server_side_encryption_algorithm: Optional[StrictStr] = Field(default=None, description="Used to specify the type of server-side encryption (SSE) to be used on the object provider. This value is used to determine the Amazon S3 header \"x-amz-server-side-encryption\" value. For example, specify \"AES256\" for SSE-S3, or \"AWS:KMS\" for SSE-KMS. By default if none is specified, \"AES256\" will be used.", alias="serverSideEncryptionAlgorithm")
    server_side_encryption_key: Optional[StrictStr] = Field(default=None, description="Used to specify the server-side encryption key that might be associated with the specified server-side encryption algorithm. This value can be the AWS KMS arn key, to be used for the Amazon S3 header \"x-amz-server-side-encryption-aws-kms-key-id\" value. Value will be ignored if encryption is \"AES256\"", alias="serverSideEncryptionKey")
    __properties: ClassVar[List[str]] = ["accessKey", "secretKey", "sessionToken", "region", "bucket", "objectPrefix", "serverSideEncryptionAlgorithm", "serverSideEncryptionKey"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of AwsTempCredentials from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if server_side_encryption_algorithm (nullable) is None
        # and model_fields_set contains the field
        if self.server_side_encryption_algorithm is None and "server_side_encryption_algorithm" in self.model_fields_set:
            _dict['serverSideEncryptionAlgorithm'] = None

        # set to None if server_side_encryption_key (nullable) is None
        # and model_fields_set contains the field
        if self.server_side_encryption_key is None and "server_side_encryption_key" in self.model_fields_set:
            _dict['serverSideEncryptionKey'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of AwsTempCredentials from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "accessKey": obj.get("accessKey"),
            "secretKey": obj.get("secretKey"),
            "sessionToken": obj.get("sessionToken"),
            "region": obj.get("region"),
            "bucket": obj.get("bucket"),
            "objectPrefix": obj.get("objectPrefix"),
            "serverSideEncryptionAlgorithm": obj.get("serverSideEncryptionAlgorithm"),
            "serverSideEncryptionKey": obj.get("serverSideEncryptionKey")
        })
        return _obj

AwsTempCredentials

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var access_key : str

The type of the None singleton.

var bucket : str

The type of the None singleton.

var model_config

The type of the None singleton.

var object_prefix : str

The type of the None singleton.

var region : str

The type of the None singleton.

var secret_key : str

The type of the None singleton.

var server_side_encryption_algorithm : str | None

The type of the None singleton.

var server_side_encryption_key : str | None

The type of the None singleton.

var session_token : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of AwsTempCredentials from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of AwsTempCredentials from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if server_side_encryption_algorithm (nullable) is None
    # and model_fields_set contains the field
    if self.server_side_encryption_algorithm is None and "server_side_encryption_algorithm" in self.model_fields_set:
        _dict['serverSideEncryptionAlgorithm'] = None

    # set to None if server_side_encryption_key (nullable) is None
    # and model_fields_set contains the field
    if self.server_side_encryption_key is None and "server_side_encryption_key" in self.model_fields_set:
        _dict['serverSideEncryptionKey'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BaseConnection (**data: Any)

Expand source code

class BaseConnection(BaseModel):
    """
    BaseConnection
    """ # noqa: E501
    authenticator: StrictStr = Field(description="Specifies the supported snowflake authenticator to use. Currently 'oauth' only is supported")
    access_token: StrictStr = Field(description="Specifies the OAuth token to use for authentication", alias="accessToken")
    dns_name: StrictStr = Field(description="snowflake dns name. Usually something like '<<account>>.snowflakecomputing.com'", alias="dnsName")
    user_principal_name: StrictStr = Field(description="Specifies the user principal name. This is required for some snowflake client (snowSQL for instance)", alias="userPrincipalName")
    database_name: StrictStr = Field(description="Specifies the database name bound to the project specified", alias="databaseName")
    schema_name: StrictStr = Field(description="Specifies the schema name bound to the project specified", alias="schemaName")
    warehouse_name: StrictStr = Field(description="Specifies the warehouse name bound to the project specified", alias="warehouseName")
    role_name: StrictStr = Field(description="Specifies the role name bound to the project specified", alias="roleName")
    __properties: ClassVar[List[str]] = ["authenticator", "accessToken", "dnsName", "userPrincipalName", "databaseName", "schemaName", "warehouseName", "roleName"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BaseConnection from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BaseConnection from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "authenticator": obj.get("authenticator"),
            "accessToken": obj.get("accessToken"),
            "dnsName": obj.get("dnsName"),
            "userPrincipalName": obj.get("userPrincipalName"),
            "databaseName": obj.get("databaseName"),
            "schemaName": obj.get("schemaName"),
            "warehouseName": obj.get("warehouseName"),
            "roleName": obj.get("roleName")
        })
        return _obj

BaseConnection

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var access_token : str

The type of the None singleton.

var authenticator : str

The type of the None singleton.

var database_name : str

The type of the None singleton.

var dns_name : str

The type of the None singleton.

var model_config

The type of the None singleton.

var role_name : str

The type of the None singleton.

var schema_name : str

The type of the None singleton.

var user_principal_name : str

The type of the None singleton.

var warehouse_name : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BaseConnection from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BaseConnection from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BaseJob (**data: Any)

Expand source code

class BaseJob(BaseModel):
    """
    BaseJob
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    description: Optional[StrictStr] = Field(default=None, description="A short description of the base job")
    table: Optional[ProjectBaseTable] = None
    type: StrictStr = Field(description="The type of the job")
    status: StrictStr = Field(description="The status of the job")
    overall_duration: Optional[StrictInt] = Field(default=None, description="The duration of the job expressed in milliseconds", alias="overallDuration")
    details: Optional[StrictStr] = Field(default=None, description="Detailed description of the job")
    bytes_billed: Optional[StrictInt] = Field(default=None, description="Bytes billed", alias="bytesBilled")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "description", "table", "type", "status", "overallDuration", "details", "bytesBilled"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['COPYTABLE', 'EXPORTTABLE', 'CREATETABLE', 'EXECUTEQUERY', 'LOADDATA', 'PREPAREDATA']):
            raise ValueError("must be one of enum values ('COPYTABLE', 'EXPORTTABLE', 'CREATETABLE', 'EXECUTEQUERY', 'LOADDATA', 'PREPAREDATA')")
        return value

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['CREATED', 'SUCCEEDED', 'FAILED', 'PENDING', 'INPROGRESS', 'ABORTED']):
            raise ValueError("must be one of enum values ('CREATED', 'SUCCEEDED', 'FAILED', 'PENDING', 'INPROGRESS', 'ABORTED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BaseJob from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of table
        if self.table:
            _dict['table'] = self.table.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if table (nullable) is None
        # and model_fields_set contains the field
        if self.table is None and "table" in self.model_fields_set:
            _dict['table'] = None

        # set to None if overall_duration (nullable) is None
        # and model_fields_set contains the field
        if self.overall_duration is None and "overall_duration" in self.model_fields_set:
            _dict['overallDuration'] = None

        # set to None if details (nullable) is None
        # and model_fields_set contains the field
        if self.details is None and "details" in self.model_fields_set:
            _dict['details'] = None

        # set to None if bytes_billed (nullable) is None
        # and model_fields_set contains the field
        if self.bytes_billed is None and "bytes_billed" in self.model_fields_set:
            _dict['bytesBilled'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BaseJob from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "description": obj.get("description"),
            "table": ProjectBaseTable.from_dict(obj["table"]) if obj.get("table") is not None else None,
            "type": obj.get("type"),
            "status": obj.get("status"),
            "overallDuration": obj.get("overallDuration"),
            "details": obj.get("details"),
            "bytesBilled": obj.get("bytesBilled")
        })
        return _obj

BaseJob

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bytes_billed : int | None

The type of the None singleton.

var description : str | None

The type of the None singleton.

var details : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var overall_duration : int | None

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var status : str

The type of the None singleton.

var table : ProjectBaseTable | None

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BaseJob from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BaseJob from a JSON string

def status_validate_enum(value)

Validates the enum

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of table
    if self.table:
        _dict['table'] = self.table.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if table (nullable) is None
    # and model_fields_set contains the field
    if self.table is None and "table" in self.model_fields_set:
        _dict['table'] = None

    # set to None if overall_duration (nullable) is None
    # and model_fields_set contains the field
    if self.overall_duration is None and "overall_duration" in self.model_fields_set:
        _dict['overallDuration'] = None

    # set to None if details (nullable) is None
    # and model_fields_set contains the field
    if self.details is None and "details" in self.model_fields_set:
        _dict['details'] = None

    # set to None if bytes_billed (nullable) is None
    # and model_fields_set contains the field
    if self.bytes_billed is None and "bytes_billed" in self.model_fields_set:
        _dict['bytesBilled'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BaseJobList (**data: Any)

Expand source code

class BaseJobList(BaseModel):
    """
    BaseJobList
    """ # noqa: E501
    items: List[BaseJob]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BaseJobList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BaseJobList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [BaseJob.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

BaseJobList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[BaseJob]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BaseJobList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BaseJobList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BenchSettings (**data: Any)

Expand source code

class BenchSettings(BaseModel):
    """
    BenchSettings
    """ # noqa: E501
    cluster_compatible: StrictBool = Field(alias="clusterCompatible")
    access: DockerImageAccess
    __properties: ClassVar[List[str]] = ["clusterCompatible", "access"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BenchSettings from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of access
        if self.access:
            _dict['access'] = self.access.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BenchSettings from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "clusterCompatible": obj.get("clusterCompatible"),
            "access": DockerImageAccess.from_dict(obj["access"]) if obj.get("access") is not None else None
        })
        return _obj

BenchSettings

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var access : DockerImageAccess

The type of the None singleton.

var cluster_compatible : bool

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BenchSettings from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BenchSettings from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of access
    if self.access:
        _dict['access'] = self.access.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Bundle (**data: Any)

Expand source code

class Bundle(BaseModel):
    """
    Bundle
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    short_description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = Field(default=None, alias="shortDescription")
    region: Region
    metadata_model: Optional[MetadataModel] = Field(default=None, alias="metadataModel")
    release_version: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(alias="releaseVersion")
    version_comment: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = Field(default=None, alias="versionComment")
    status: StrictStr
    categories: Optional[List[Optional[StrictStr]]] = Field(default=None, description="category tags as string array")
    links: Optional[Links] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "shortDescription", "region", "metadataModel", "releaseVersion", "versionComment", "status", "categories", "links"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['DRAFT', 'RELEASED', 'DEPRECATED']):
            raise ValueError("must be one of enum values ('DRAFT', 'RELEASED', 'DEPRECATED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Bundle from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of region
        if self.region:
            _dict['region'] = self.region.to_dict()
        # override the default output from pydantic by calling `to_dict()` of metadata_model
        if self.metadata_model:
            _dict['metadataModel'] = self.metadata_model.to_dict()
        # override the default output from pydantic by calling `to_dict()` of links
        if self.links:
            _dict['links'] = self.links.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if short_description (nullable) is None
        # and model_fields_set contains the field
        if self.short_description is None and "short_description" in self.model_fields_set:
            _dict['shortDescription'] = None

        # set to None if metadata_model (nullable) is None
        # and model_fields_set contains the field
        if self.metadata_model is None and "metadata_model" in self.model_fields_set:
            _dict['metadataModel'] = None

        # set to None if version_comment (nullable) is None
        # and model_fields_set contains the field
        if self.version_comment is None and "version_comment" in self.model_fields_set:
            _dict['versionComment'] = None

        # set to None if categories (nullable) is None
        # and model_fields_set contains the field
        if self.categories is None and "categories" in self.model_fields_set:
            _dict['categories'] = None

        # set to None if links (nullable) is None
        # and model_fields_set contains the field
        if self.links is None and "links" in self.model_fields_set:
            _dict['links'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Bundle from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "shortDescription": obj.get("shortDescription"),
            "region": Region.from_dict(obj["region"]) if obj.get("region") is not None else None,
            "metadataModel": MetadataModel.from_dict(obj["metadataModel"]) if obj.get("metadataModel") is not None else None,
            "releaseVersion": obj.get("releaseVersion"),
            "versionComment": obj.get("versionComment"),
            "status": obj.get("status"),
            "categories": obj.get("categories"),
            "links": Links.from_dict(obj["links"]) if obj.get("links") is not None else None
        })
        return _obj

Bundle

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var categories : List[str | None] | None

The type of the None singleton.

var id : str

The type of the None singleton.

var links : Links | None

The type of the None singleton.

var metadata_model : MetadataModel | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var region : Region

The type of the None singleton.

var release_version : str

The type of the None singleton.

var short_description : str | None

The type of the None singleton.

var status : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var version_comment : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Bundle from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Bundle from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of region
    if self.region:
        _dict['region'] = self.region.to_dict()
    # override the default output from pydantic by calling `to_dict()` of metadata_model
    if self.metadata_model:
        _dict['metadataModel'] = self.metadata_model.to_dict()
    # override the default output from pydantic by calling `to_dict()` of links
    if self.links:
        _dict['links'] = self.links.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if short_description (nullable) is None
    # and model_fields_set contains the field
    if self.short_description is None and "short_description" in self.model_fields_set:
        _dict['shortDescription'] = None

    # set to None if metadata_model (nullable) is None
    # and model_fields_set contains the field
    if self.metadata_model is None and "metadata_model" in self.model_fields_set:
        _dict['metadataModel'] = None

    # set to None if version_comment (nullable) is None
    # and model_fields_set contains the field
    if self.version_comment is None and "version_comment" in self.model_fields_set:
        _dict['versionComment'] = None

    # set to None if categories (nullable) is None
    # and model_fields_set contains the field
    if self.categories is None and "categories" in self.model_fields_set:
        _dict['categories'] = None

    # set to None if links (nullable) is None
    # and model_fields_set contains the field
    if self.links is None and "links" in self.model_fields_set:
        _dict['links'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleApi (api_client=None)

Expand source code

class BundleApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def accept_terms_of_use_bundle(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle where the terms of use are accepted of.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """accept terms of use for a bundle


        :param bundle_id: The ID of the bundle where the terms of use are accepted of. (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._accept_terms_of_use_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def accept_terms_of_use_bundle_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle where the terms of use are accepted of.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """accept terms of use for a bundle


        :param bundle_id: The ID of the bundle where the terms of use are accepted of. (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._accept_terms_of_use_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def accept_terms_of_use_bundle_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle where the terms of use are accepted of.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """accept terms of use for a bundle


        :param bundle_id: The ID of the bundle where the terms of use are accepted of. (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._accept_terms_of_use_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _accept_terms_of_use_bundle_serialize(
        self,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}/termsOfUse:accept',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_bundle(
        self,
        create_bundle: CreateBundle,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Bundle:
        """Create a new bundle


        :param create_bundle: (required)
        :type create_bundle: CreateBundle
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_bundle_serialize(
            create_bundle=create_bundle,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "Bundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_bundle_with_http_info(
        self,
        create_bundle: CreateBundle,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Bundle]:
        """Create a new bundle


        :param create_bundle: (required)
        :type create_bundle: CreateBundle
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_bundle_serialize(
            create_bundle=create_bundle,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "Bundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_bundle_without_preload_content(
        self,
        create_bundle: CreateBundle,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a new bundle


        :param create_bundle: (required)
        :type create_bundle: CreateBundle
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_bundle_serialize(
            create_bundle=create_bundle,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "Bundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_bundle_serialize(
        self,
        create_bundle,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_bundle is not None:
            _body_params = create_bundle


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def deprecate_bundle(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to deprecate.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """deprecate a bundle


        :param bundle_id: The ID of the bundle to deprecate. (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._deprecate_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def deprecate_bundle_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to deprecate.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """deprecate a bundle


        :param bundle_id: The ID of the bundle to deprecate. (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._deprecate_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def deprecate_bundle_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to deprecate.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """deprecate a bundle


        :param bundle_id: The ID of the bundle to deprecate. (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._deprecate_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _deprecate_bundle_serialize(
        self,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}:deprecate',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_bundle(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Bundle:
        """Retrieve a bundle.


        :param bundle_id: The ID of the bundle to retrieve (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Bundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Bundle]:
        """Retrieve a bundle.


        :param bundle_id: The ID of the bundle to retrieve (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Bundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a bundle.


        :param bundle_id: The ID of the bundle to retrieve (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Bundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_serialize(
        self,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_bundle_terms_of_use(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> TermsOfUse:
        """Retrieve the last version of terms of use for a bundle.


        :param bundle_id: The ID of the bundle of the terms of use to retrieve (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_terms_of_use_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_terms_of_use_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[TermsOfUse]:
        """Retrieve the last version of terms of use for a bundle.


        :param bundle_id: The ID of the bundle of the terms of use to retrieve (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_terms_of_use_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_terms_of_use_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the last version of terms of use for a bundle.


        :param bundle_id: The ID of the bundle of the terms of use to retrieve (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_terms_of_use_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_terms_of_use_serialize(
        self,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/termsOfUse',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_bundles(
        self,
        search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundlePagedList:
        """Retrieve a list of bundles.


        :param search: Search
        :type search: str
        :param user_tags: User tags to filter on
        :type user_tags: str
        :param technical_tags: Technical tags to filter on
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundles_serialize(
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundlePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundles_with_http_info(
        self,
        search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundlePagedList]:
        """Retrieve a list of bundles.


        :param search: Search
        :type search: str
        :param user_tags: User tags to filter on
        :type user_tags: str
        :param technical_tags: Technical tags to filter on
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundles_serialize(
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundlePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundles_without_preload_content(
        self,
        search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of bundles.


        :param search: Search
        :type search: str
        :param user_tags: User tags to filter on
        :type user_tags: str
        :param technical_tags: Technical tags to filter on
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundles_serialize(
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundlePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundles_serialize(
        self,
        search,
        user_tags,
        technical_tags,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if search is not None:
            
            _query_params.append(('search', search))
            
        if user_tags is not None:
            
            _query_params.append(('userTags', user_tags))
            
        if technical_tags is not None:
            
            _query_params.append(('technicalTags', technical_tags))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_terms_of_use_acceptance(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use acceptance records.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> TermsOfUseAcceptance:
        """Retrieve the acceptance record for a bundle for the current user.


        :param bundle_id: The ID of the bundle of the terms of use acceptance records. (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_terms_of_use_acceptance_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUseAcceptance",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_terms_of_use_acceptance_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use acceptance records.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[TermsOfUseAcceptance]:
        """Retrieve the acceptance record for a bundle for the current user.


        :param bundle_id: The ID of the bundle of the terms of use acceptance records. (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_terms_of_use_acceptance_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUseAcceptance",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_terms_of_use_acceptance_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use acceptance records.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the acceptance record for a bundle for the current user.


        :param bundle_id: The ID of the bundle of the terms of use acceptance records. (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_terms_of_use_acceptance_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUseAcceptance",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_terms_of_use_acceptance_serialize(
        self,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/termsOfUse/userAcceptance/currentUser',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def insert_bundle_terms_of_use(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to update")],
        create_terms_of_use: CreateTermsOfUse,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> TermsOfUse:
        """Insert a new version of the terms of use for a bundle


        :param bundle_id: The ID of the bundle to update (required)
        :type bundle_id: str
        :param create_terms_of_use: (required)
        :type create_terms_of_use: CreateTermsOfUse
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._insert_bundle_terms_of_use_serialize(
            bundle_id=bundle_id,
            create_terms_of_use=create_terms_of_use,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def insert_bundle_terms_of_use_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to update")],
        create_terms_of_use: CreateTermsOfUse,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[TermsOfUse]:
        """Insert a new version of the terms of use for a bundle


        :param bundle_id: The ID of the bundle to update (required)
        :type bundle_id: str
        :param create_terms_of_use: (required)
        :type create_terms_of_use: CreateTermsOfUse
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._insert_bundle_terms_of_use_serialize(
            bundle_id=bundle_id,
            create_terms_of_use=create_terms_of_use,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def insert_bundle_terms_of_use_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to update")],
        create_terms_of_use: CreateTermsOfUse,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Insert a new version of the terms of use for a bundle


        :param bundle_id: The ID of the bundle to update (required)
        :type bundle_id: str
        :param create_terms_of_use: (required)
        :type create_terms_of_use: CreateTermsOfUse
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._insert_bundle_terms_of_use_serialize(
            bundle_id=bundle_id,
            create_terms_of_use=create_terms_of_use,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _insert_bundle_terms_of_use_serialize(
        self,
        bundle_id,
        create_terms_of_use,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_terms_of_use is not None:
            _body_params = create_terms_of_use


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}/termsOfUse:new',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def release_bundle(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to release")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """release a bundle


        :param bundle_id: The ID of the bundle to release (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._release_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def release_bundle_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to release")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """release a bundle


        :param bundle_id: The ID of the bundle to release (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._release_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def release_bundle_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to release")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """release a bundle


        :param bundle_id: The ID of the bundle to release (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._release_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _release_bundle_serialize(
        self,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}:release',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def accept_terms_of_use_bundle(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle where the terms of use are accepted of.')]) ‑> None

Expand source code

@validate_call
def accept_terms_of_use_bundle(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle where the terms of use are accepted of.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """accept terms of use for a bundle


    :param bundle_id: The ID of the bundle where the terms of use are accepted of. (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._accept_terms_of_use_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

accept terms of use for a bundle

:param bundle_id: The ID of the bundle where the terms of use are accepted of. (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def accept_terms_of_use_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle where the terms of use are accepted of.')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def accept_terms_of_use_bundle_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle where the terms of use are accepted of.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """accept terms of use for a bundle


    :param bundle_id: The ID of the bundle where the terms of use are accepted of. (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._accept_terms_of_use_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

accept terms of use for a bundle

:param bundle_id: The ID of the bundle where the terms of use are accepted of. (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def accept_terms_of_use_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle where the terms of use are accepted of.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def accept_terms_of_use_bundle_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle where the terms of use are accepted of.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """accept terms of use for a bundle


    :param bundle_id: The ID of the bundle where the terms of use are accepted of. (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._accept_terms_of_use_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

accept terms of use for a bundle

:param bundle_id: The ID of the bundle where the terms of use are accepted of. (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_bundle(self,
create_bundle: CreateBundle) ‑> Bundle

Expand source code

@validate_call
def create_bundle(
    self,
    create_bundle: CreateBundle,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Bundle:
    """Create a new bundle


    :param create_bundle: (required)
    :type create_bundle: CreateBundle
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_bundle_serialize(
        create_bundle=create_bundle,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "Bundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a new bundle

:param create_bundle: (required) :type create_bundle: CreateBundle :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_bundle_with_http_info(self,
create_bundle: CreateBundle) ‑> ApiResponse[Bundle]

Expand source code

@validate_call
def create_bundle_with_http_info(
    self,
    create_bundle: CreateBundle,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Bundle]:
    """Create a new bundle


    :param create_bundle: (required)
    :type create_bundle: CreateBundle
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_bundle_serialize(
        create_bundle=create_bundle,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "Bundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a new bundle

:param create_bundle: (required) :type create_bundle: CreateBundle :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_bundle_without_preload_content(self,
create_bundle: CreateBundle) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_bundle_without_preload_content(
    self,
    create_bundle: CreateBundle,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a new bundle


    :param create_bundle: (required)
    :type create_bundle: CreateBundle
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_bundle_serialize(
        create_bundle=create_bundle,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "Bundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a new bundle

:param create_bundle: (required) :type create_bundle: CreateBundle :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def deprecate_bundle(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to deprecate.')]) ‑> None

Expand source code

@validate_call
def deprecate_bundle(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to deprecate.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """deprecate a bundle


    :param bundle_id: The ID of the bundle to deprecate. (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._deprecate_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

deprecate a bundle

:param bundle_id: The ID of the bundle to deprecate. (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def deprecate_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to deprecate.')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def deprecate_bundle_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to deprecate.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """deprecate a bundle


    :param bundle_id: The ID of the bundle to deprecate. (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._deprecate_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

deprecate a bundle

:param bundle_id: The ID of the bundle to deprecate. (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def deprecate_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to deprecate.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def deprecate_bundle_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to deprecate.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """deprecate a bundle


    :param bundle_id: The ID of the bundle to deprecate. (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._deprecate_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

deprecate a bundle

:param bundle_id: The ID of the bundle to deprecate. (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to retrieve')]) ‑> Bundle

Expand source code

@validate_call
def get_bundle(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Bundle:
    """Retrieve a bundle.


    :param bundle_id: The ID of the bundle to retrieve (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Bundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a bundle.

:param bundle_id: The ID of the bundle to retrieve (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_terms_of_use(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle of the terms of use to retrieve')]) ‑> TermsOfUse

Expand source code

@validate_call
def get_bundle_terms_of_use(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> TermsOfUse:
    """Retrieve the last version of terms of use for a bundle.


    :param bundle_id: The ID of the bundle of the terms of use to retrieve (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_terms_of_use_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUse",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the last version of terms of use for a bundle.

:param bundle_id: The ID of the bundle of the terms of use to retrieve (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_terms_of_use_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle of the terms of use to retrieve')]) ‑> ApiResponse[TermsOfUse]

Expand source code

@validate_call
def get_bundle_terms_of_use_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[TermsOfUse]:
    """Retrieve the last version of terms of use for a bundle.


    :param bundle_id: The ID of the bundle of the terms of use to retrieve (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_terms_of_use_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUse",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the last version of terms of use for a bundle.

:param bundle_id: The ID of the bundle of the terms of use to retrieve (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_terms_of_use_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle of the terms of use to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_terms_of_use_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the last version of terms of use for a bundle.


    :param bundle_id: The ID of the bundle of the terms of use to retrieve (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_terms_of_use_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUse",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the last version of terms of use for a bundle.

:param bundle_id: The ID of the bundle of the terms of use to retrieve (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to retrieve')]) ‑> ApiResponse[Bundle]

Expand source code

@validate_call
def get_bundle_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Bundle]:
    """Retrieve a bundle.


    :param bundle_id: The ID of the bundle to retrieve (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Bundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a bundle.

:param bundle_id: The ID of the bundle to retrieve (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a bundle.


    :param bundle_id: The ID of the bundle to retrieve (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Bundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a bundle.

:param bundle_id: The ID of the bundle to retrieve (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundles(self,
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='User tags to filter on')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Technical tags to filter on')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription')] = None) ‑> BundlePagedList

Expand source code

@validate_call
def get_bundles(
    self,
    search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundlePagedList:
    """Retrieve a list of bundles.


    :param search: Search
    :type search: str
    :param user_tags: User tags to filter on
    :type user_tags: str
    :param technical_tags: Technical tags to filter on
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundles_serialize(
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundlePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of bundles.

:param search: Search :type search: str :param user_tags: User tags to filter on :type user_tags: str :param technical_tags: Technical tags to filter on :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundles_with_http_info(self,
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='User tags to filter on')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Technical tags to filter on')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription')] = None) ‑> ApiResponse[BundlePagedList]

Expand source code

@validate_call
def get_bundles_with_http_info(
    self,
    search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundlePagedList]:
    """Retrieve a list of bundles.


    :param search: Search
    :type search: str
    :param user_tags: User tags to filter on
    :type user_tags: str
    :param technical_tags: Technical tags to filter on
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundles_serialize(
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundlePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of bundles.

:param search: Search :type search: str :param user_tags: User tags to filter on :type user_tags: str :param technical_tags: Technical tags to filter on :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundles_without_preload_content(self,
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='User tags to filter on')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Technical tags to filter on')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundles_without_preload_content(
    self,
    search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of bundles.


    :param search: Search
    :type search: str
    :param user_tags: User tags to filter on
    :type user_tags: str
    :param technical_tags: Technical tags to filter on
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundles_serialize(
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundlePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of bundles.

:param search: Search :type search: str :param user_tags: User tags to filter on :type user_tags: str :param technical_tags: Technical tags to filter on :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_terms_of_use_acceptance(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle of the terms of use acceptance records.')]) ‑> TermsOfUseAcceptance

Expand source code

@validate_call
def get_terms_of_use_acceptance(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use acceptance records.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> TermsOfUseAcceptance:
    """Retrieve the acceptance record for a bundle for the current user.


    :param bundle_id: The ID of the bundle of the terms of use acceptance records. (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_terms_of_use_acceptance_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUseAcceptance",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the acceptance record for a bundle for the current user.

:param bundle_id: The ID of the bundle of the terms of use acceptance records. (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_terms_of_use_acceptance_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle of the terms of use acceptance records.')]) ‑> ApiResponse[TermsOfUseAcceptance]

Expand source code

@validate_call
def get_terms_of_use_acceptance_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use acceptance records.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[TermsOfUseAcceptance]:
    """Retrieve the acceptance record for a bundle for the current user.


    :param bundle_id: The ID of the bundle of the terms of use acceptance records. (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_terms_of_use_acceptance_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUseAcceptance",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the acceptance record for a bundle for the current user.

:param bundle_id: The ID of the bundle of the terms of use acceptance records. (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_terms_of_use_acceptance_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle of the terms of use acceptance records.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_terms_of_use_acceptance_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle of the terms of use acceptance records.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the acceptance record for a bundle for the current user.


    :param bundle_id: The ID of the bundle of the terms of use acceptance records. (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_terms_of_use_acceptance_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUseAcceptance",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the acceptance record for a bundle for the current user.

:param bundle_id: The ID of the bundle of the terms of use acceptance records. (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def insert_bundle_terms_of_use(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to update')],
create_terms_of_use: CreateTermsOfUse) ‑> TermsOfUse

Expand source code

@validate_call
def insert_bundle_terms_of_use(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to update")],
    create_terms_of_use: CreateTermsOfUse,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> TermsOfUse:
    """Insert a new version of the terms of use for a bundle


    :param bundle_id: The ID of the bundle to update (required)
    :type bundle_id: str
    :param create_terms_of_use: (required)
    :type create_terms_of_use: CreateTermsOfUse
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._insert_bundle_terms_of_use_serialize(
        bundle_id=bundle_id,
        create_terms_of_use=create_terms_of_use,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUse",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Insert a new version of the terms of use for a bundle

:param bundle_id: The ID of the bundle to update (required) :type bundle_id: str :param create_terms_of_use: (required) :type create_terms_of_use: CreateTermsOfUse :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def insert_bundle_terms_of_use_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to update')],
create_terms_of_use: CreateTermsOfUse) ‑> ApiResponse[TermsOfUse]

Expand source code

@validate_call
def insert_bundle_terms_of_use_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to update")],
    create_terms_of_use: CreateTermsOfUse,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[TermsOfUse]:
    """Insert a new version of the terms of use for a bundle


    :param bundle_id: The ID of the bundle to update (required)
    :type bundle_id: str
    :param create_terms_of_use: (required)
    :type create_terms_of_use: CreateTermsOfUse
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._insert_bundle_terms_of_use_serialize(
        bundle_id=bundle_id,
        create_terms_of_use=create_terms_of_use,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUse",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Insert a new version of the terms of use for a bundle

:param bundle_id: The ID of the bundle to update (required) :type bundle_id: str :param create_terms_of_use: (required) :type create_terms_of_use: CreateTermsOfUse :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def insert_bundle_terms_of_use_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to update')],
create_terms_of_use: CreateTermsOfUse) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def insert_bundle_terms_of_use_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to update")],
    create_terms_of_use: CreateTermsOfUse,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Insert a new version of the terms of use for a bundle


    :param bundle_id: The ID of the bundle to update (required)
    :type bundle_id: str
    :param create_terms_of_use: (required)
    :type create_terms_of_use: CreateTermsOfUse
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._insert_bundle_terms_of_use_serialize(
        bundle_id=bundle_id,
        create_terms_of_use=create_terms_of_use,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUse",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Insert a new version of the terms of use for a bundle

:param bundle_id: The ID of the bundle to update (required) :type bundle_id: str :param create_terms_of_use: (required) :type create_terms_of_use: CreateTermsOfUse :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def release_bundle(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to release')]) ‑> None

Expand source code

@validate_call
def release_bundle(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to release")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """release a bundle


    :param bundle_id: The ID of the bundle to release (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._release_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

release a bundle

:param bundle_id: The ID of the bundle to release (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def release_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to release')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def release_bundle_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to release")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """release a bundle


    :param bundle_id: The ID of the bundle to release (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._release_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

release a bundle

:param bundle_id: The ID of the bundle to release (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def release_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to release')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def release_bundle_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to release")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """release a bundle


    :param bundle_id: The ID of the bundle to release (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._release_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

release a bundle

:param bundle_id: The ID of the bundle to release (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class BundleData (**data: Any)

Expand source code

class BundleData(BaseModel):
    """
    BundleData
    """ # noqa: E501
    data: Data
    bundle_id: StrictStr = Field(alias="bundleId")
    __properties: ClassVar[List[str]] = ["data", "bundleId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of data
        if self.data:
            _dict['data'] = self.data.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "data": Data.from_dict(obj["data"]) if obj.get("data") is not None else None,
            "bundleId": obj.get("bundleId")
        })
        return _obj

BundleData

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bundle_id : str

The type of the None singleton.

var data : Data

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of data
    if self.data:
        _dict['data'] = self.data.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataApi (api_client=None)

Expand source code

class BundleDataApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_bundle_data(
        self,
        bundle_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[StrictStr], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[StrictStr], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered.")] = None,
        file_path: Annotated[Optional[StrictStr], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[StrictStr], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[StrictStr], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        parent_folder_id: Annotated[Optional[StrictStr], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[StrictStr], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered.")] = None,
        run_input_tag: Annotated[Optional[StrictStr], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered.")] = None,
        run_output_tag: Annotated[Optional[StrictStr], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered.")] = None,
        connector_tag: Annotated[Optional[StrictStr], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered.")] = None,
        technical_tag: Annotated[Optional[StrictStr], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered.")] = None,
        not_in_run: Annotated[Optional[StrictStr], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictStr], Field(description="When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleDataPagedList:
        """Retrieve the list of bundle data.


        :param bundle_id: (required)
        :type bundle_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: str
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: str
        :param filename_match_mode: How the filenames are filtered.
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: str
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: str
        :param format_id: The IDs of the formats to filter on.
        :type format_id: str
        :param format_code: The codes of the formats to filter on.
        :type format_code: str
        :param type: The type to filter on.
        :type type: str
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: str
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: str
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: str
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: str
        :param status_date_before: The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: str
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: str
        :param user_tag_match_mode: How the usertags are filtered.
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: str
        :param run_input_tag_match_mode: How the runInputTags are filtered.
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: str
        :param run_output_tag_match_mode: How the runOutputTags are filtered.
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: str
        :param connector_tag_match_mode: How the connectorTags are filtered.
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: str
        :param technical_tag_match_mode: How the technicalTags are filtered.
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: str
        :param not_linked_to_sample: When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.
        :type not_linked_to_sample: str
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_serialize(
            bundle_id=bundle_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_data_with_http_info(
        self,
        bundle_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[StrictStr], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[StrictStr], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered.")] = None,
        file_path: Annotated[Optional[StrictStr], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[StrictStr], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[StrictStr], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        parent_folder_id: Annotated[Optional[StrictStr], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[StrictStr], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered.")] = None,
        run_input_tag: Annotated[Optional[StrictStr], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered.")] = None,
        run_output_tag: Annotated[Optional[StrictStr], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered.")] = None,
        connector_tag: Annotated[Optional[StrictStr], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered.")] = None,
        technical_tag: Annotated[Optional[StrictStr], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered.")] = None,
        not_in_run: Annotated[Optional[StrictStr], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictStr], Field(description="When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleDataPagedList]:
        """Retrieve the list of bundle data.


        :param bundle_id: (required)
        :type bundle_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: str
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: str
        :param filename_match_mode: How the filenames are filtered.
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: str
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: str
        :param format_id: The IDs of the formats to filter on.
        :type format_id: str
        :param format_code: The codes of the formats to filter on.
        :type format_code: str
        :param type: The type to filter on.
        :type type: str
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: str
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: str
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: str
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: str
        :param status_date_before: The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: str
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: str
        :param user_tag_match_mode: How the usertags are filtered.
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: str
        :param run_input_tag_match_mode: How the runInputTags are filtered.
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: str
        :param run_output_tag_match_mode: How the runOutputTags are filtered.
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: str
        :param connector_tag_match_mode: How the connectorTags are filtered.
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: str
        :param technical_tag_match_mode: How the technicalTags are filtered.
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: str
        :param not_linked_to_sample: When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.
        :type not_linked_to_sample: str
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_serialize(
            bundle_id=bundle_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_data_without_preload_content(
        self,
        bundle_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[StrictStr], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[StrictStr], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered.")] = None,
        file_path: Annotated[Optional[StrictStr], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[StrictStr], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[StrictStr], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        parent_folder_id: Annotated[Optional[StrictStr], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[StrictStr], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered.")] = None,
        run_input_tag: Annotated[Optional[StrictStr], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered.")] = None,
        run_output_tag: Annotated[Optional[StrictStr], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered.")] = None,
        connector_tag: Annotated[Optional[StrictStr], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered.")] = None,
        technical_tag: Annotated[Optional[StrictStr], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered.")] = None,
        not_in_run: Annotated[Optional[StrictStr], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictStr], Field(description="When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the list of bundle data.


        :param bundle_id: (required)
        :type bundle_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: str
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: str
        :param filename_match_mode: How the filenames are filtered.
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: str
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: str
        :param format_id: The IDs of the formats to filter on.
        :type format_id: str
        :param format_code: The codes of the formats to filter on.
        :type format_code: str
        :param type: The type to filter on.
        :type type: str
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: str
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: str
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: str
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: str
        :param status_date_before: The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: str
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: str
        :param user_tag_match_mode: How the usertags are filtered.
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: str
        :param run_input_tag_match_mode: How the runInputTags are filtered.
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: str
        :param run_output_tag_match_mode: How the runOutputTags are filtered.
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: str
        :param connector_tag_match_mode: How the connectorTags are filtered.
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: str
        :param technical_tag_match_mode: How the technicalTags are filtered.
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: str
        :param not_linked_to_sample: When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.
        :type not_linked_to_sample: str
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_serialize(
            bundle_id=bundle_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_data_serialize(
        self,
        bundle_id,
        full_text,
        id,
        filename,
        filename_match_mode,
        file_path,
        file_path_match_mode,
        status,
        format_id,
        format_code,
        type,
        parent_folder_id,
        parent_folder_path,
        creation_date_after,
        creation_date_before,
        status_date_after,
        status_date_before,
        user_tag,
        user_tag_match_mode,
        run_input_tag,
        run_input_tag_match_mode,
        run_output_tag,
        run_output_tag_match_mode,
        connector_tag,
        connector_tag_match_mode,
        technical_tag,
        technical_tag_match_mode,
        not_in_run,
        not_linked_to_sample,
        instrument_run_id,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'instrumentRunId': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        if full_text is not None:
            
            _query_params.append(('fullText', full_text))
            
        if id is not None:
            
            _query_params.append(('id', id))
            
        if filename is not None:
            
            _query_params.append(('filename', filename))
            
        if filename_match_mode is not None:
            
            _query_params.append(('filenameMatchMode', filename_match_mode))
            
        if file_path is not None:
            
            _query_params.append(('filePath', file_path))
            
        if file_path_match_mode is not None:
            
            _query_params.append(('filePathMatchMode', file_path_match_mode))
            
        if status is not None:
            
            _query_params.append(('status', status))
            
        if format_id is not None:
            
            _query_params.append(('formatId', format_id))
            
        if format_code is not None:
            
            _query_params.append(('formatCode', format_code))
            
        if type is not None:
            
            _query_params.append(('type', type))
            
        if parent_folder_id is not None:
            
            _query_params.append(('parentFolderId', parent_folder_id))
            
        if parent_folder_path is not None:
            
            _query_params.append(('parentFolderPath', parent_folder_path))
            
        if creation_date_after is not None:
            
            _query_params.append(('creationDateAfter', creation_date_after))
            
        if creation_date_before is not None:
            
            _query_params.append(('creationDateBefore', creation_date_before))
            
        if status_date_after is not None:
            
            _query_params.append(('statusDateAfter', status_date_after))
            
        if status_date_before is not None:
            
            _query_params.append(('statusDateBefore', status_date_before))
            
        if user_tag is not None:
            
            _query_params.append(('userTag', user_tag))
            
        if user_tag_match_mode is not None:
            
            _query_params.append(('userTagMatchMode', user_tag_match_mode))
            
        if run_input_tag is not None:
            
            _query_params.append(('runInputTag', run_input_tag))
            
        if run_input_tag_match_mode is not None:
            
            _query_params.append(('runInputTagMatchMode', run_input_tag_match_mode))
            
        if run_output_tag is not None:
            
            _query_params.append(('runOutputTag', run_output_tag))
            
        if run_output_tag_match_mode is not None:
            
            _query_params.append(('runOutputTagMatchMode', run_output_tag_match_mode))
            
        if connector_tag is not None:
            
            _query_params.append(('connectorTag', connector_tag))
            
        if connector_tag_match_mode is not None:
            
            _query_params.append(('connectorTagMatchMode', connector_tag_match_mode))
            
        if technical_tag is not None:
            
            _query_params.append(('technicalTag', technical_tag))
            
        if technical_tag_match_mode is not None:
            
            _query_params.append(('technicalTagMatchMode', technical_tag_match_mode))
            
        if not_in_run is not None:
            
            _query_params.append(('notInRun', not_in_run))
            
        if not_linked_to_sample is not None:
            
            _query_params.append(('notLinkedToSample', not_linked_to_sample))
            
        if instrument_run_id is not None:
            
            _query_params.append(('instrumentRunId', instrument_run_id))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/data',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def link_data_to_bundle(
        self,
        bundle_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Link data to this bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_data_to_bundle_serialize(
            bundle_id=bundle_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def link_data_to_bundle_with_http_info(
        self,
        bundle_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Link data to this bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_data_to_bundle_serialize(
            bundle_id=bundle_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def link_data_to_bundle_without_preload_content(
        self,
        bundle_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Link data to this bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_data_to_bundle_serialize(
            bundle_id=bundle_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _link_data_to_bundle_serialize(
        self,
        bundle_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}/data/{dataId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unlink_data_from_bundle(
        self,
        bundle_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Unlink data from this bundle.

        Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Bundle Data Unlinking Batch' for recursive unlinking.

        :param bundle_id: (required)
        :type bundle_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_data_from_bundle_serialize(
            bundle_id=bundle_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unlink_data_from_bundle_with_http_info(
        self,
        bundle_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Unlink data from this bundle.

        Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Bundle Data Unlinking Batch' for recursive unlinking.

        :param bundle_id: (required)
        :type bundle_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_data_from_bundle_serialize(
            bundle_id=bundle_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unlink_data_from_bundle_without_preload_content(
        self,
        bundle_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Unlink data from this bundle.

        Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Bundle Data Unlinking Batch' for recursive unlinking.

        :param bundle_id: (required)
        :type bundle_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_data_from_bundle_serialize(
            bundle_id=bundle_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unlink_data_from_bundle_serialize(
        self,
        bundle_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/bundles/{bundleId}/data/{dataId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_bundle_data(self,
bundle_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered.')] = None,
file_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
parent_folder_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered.')] = None,
run_input_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered.')] = None,
run_output_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered.')] = None,
connector_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered.')] = None,
technical_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered.')] = None,
not_in_run: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only date that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> BundleDataPagedList

Expand source code

@validate_call
def get_bundle_data(
    self,
    bundle_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[StrictStr], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[StrictStr], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered.")] = None,
    file_path: Annotated[Optional[StrictStr], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[StrictStr], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[StrictStr], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    parent_folder_id: Annotated[Optional[StrictStr], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[StrictStr], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered.")] = None,
    run_input_tag: Annotated[Optional[StrictStr], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered.")] = None,
    run_output_tag: Annotated[Optional[StrictStr], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered.")] = None,
    connector_tag: Annotated[Optional[StrictStr], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered.")] = None,
    technical_tag: Annotated[Optional[StrictStr], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered.")] = None,
    not_in_run: Annotated[Optional[StrictStr], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictStr], Field(description="When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleDataPagedList:
    """Retrieve the list of bundle data.


    :param bundle_id: (required)
    :type bundle_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: str
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: str
    :param filename_match_mode: How the filenames are filtered.
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: str
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: str
    :param format_id: The IDs of the formats to filter on.
    :type format_id: str
    :param format_code: The codes of the formats to filter on.
    :type format_code: str
    :param type: The type to filter on.
    :type type: str
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: str
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: str
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: str
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: str
    :param status_date_before: The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: str
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: str
    :param user_tag_match_mode: How the usertags are filtered.
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: str
    :param run_input_tag_match_mode: How the runInputTags are filtered.
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: str
    :param run_output_tag_match_mode: How the runOutputTags are filtered.
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: str
    :param connector_tag_match_mode: How the connectorTags are filtered.
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: str
    :param technical_tag_match_mode: How the technicalTags are filtered.
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: str
    :param not_linked_to_sample: When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.
    :type not_linked_to_sample: str
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_serialize(
        bundle_id=bundle_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the list of bundle data.

:param bundle_id: (required) :type bundle_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: str :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: str :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: str :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: str :param format_id: The IDs of the formats to filter on. :type format_id: str :param format_code: The codes of the formats to filter on. :type format_code: str :param type: The type to filter on. :type type: str :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: str :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: str :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: str :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: str :param status_date_before: The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: str :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: str :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: str :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: str :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: str :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: str :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: str :param not_linked_to_sample: When set to true only date that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: str :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered.')] = None,
file_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
parent_folder_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered.')] = None,
run_input_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered.')] = None,
run_output_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered.')] = None,
connector_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered.')] = None,
technical_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered.')] = None,
not_in_run: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only date that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> ApiResponse[BundleDataPagedList]

Expand source code

@validate_call
def get_bundle_data_with_http_info(
    self,
    bundle_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[StrictStr], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[StrictStr], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered.")] = None,
    file_path: Annotated[Optional[StrictStr], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[StrictStr], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[StrictStr], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    parent_folder_id: Annotated[Optional[StrictStr], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[StrictStr], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered.")] = None,
    run_input_tag: Annotated[Optional[StrictStr], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered.")] = None,
    run_output_tag: Annotated[Optional[StrictStr], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered.")] = None,
    connector_tag: Annotated[Optional[StrictStr], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered.")] = None,
    technical_tag: Annotated[Optional[StrictStr], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered.")] = None,
    not_in_run: Annotated[Optional[StrictStr], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictStr], Field(description="When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleDataPagedList]:
    """Retrieve the list of bundle data.


    :param bundle_id: (required)
    :type bundle_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: str
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: str
    :param filename_match_mode: How the filenames are filtered.
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: str
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: str
    :param format_id: The IDs of the formats to filter on.
    :type format_id: str
    :param format_code: The codes of the formats to filter on.
    :type format_code: str
    :param type: The type to filter on.
    :type type: str
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: str
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: str
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: str
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: str
    :param status_date_before: The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: str
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: str
    :param user_tag_match_mode: How the usertags are filtered.
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: str
    :param run_input_tag_match_mode: How the runInputTags are filtered.
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: str
    :param run_output_tag_match_mode: How the runOutputTags are filtered.
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: str
    :param connector_tag_match_mode: How the connectorTags are filtered.
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: str
    :param technical_tag_match_mode: How the technicalTags are filtered.
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: str
    :param not_linked_to_sample: When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.
    :type not_linked_to_sample: str
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_serialize(
        bundle_id=bundle_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the list of bundle data.

:param bundle_id: (required) :type bundle_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: str :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: str :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: str :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: str :param format_id: The IDs of the formats to filter on. :type format_id: str :param format_code: The codes of the formats to filter on. :type format_code: str :param type: The type to filter on. :type type: str :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: str :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: str :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: str :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: str :param status_date_before: The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: str :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: str :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: str :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: str :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: str :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: str :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: str :param not_linked_to_sample: When set to true only date that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: str :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered.')] = None,
file_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
parent_folder_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered.')] = None,
run_input_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered.')] = None,
run_output_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered.')] = None,
connector_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered.')] = None,
technical_tag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered.')] = None,
not_in_run: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only date that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_data_without_preload_content(
    self,
    bundle_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[StrictStr], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[StrictStr], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered.")] = None,
    file_path: Annotated[Optional[StrictStr], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[StrictStr], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[StrictStr], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    parent_folder_id: Annotated[Optional[StrictStr], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[StrictStr], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[StrictStr], Field(description="The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[StrictStr], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered.")] = None,
    run_input_tag: Annotated[Optional[StrictStr], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered.")] = None,
    run_output_tag: Annotated[Optional[StrictStr], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered.")] = None,
    connector_tag: Annotated[Optional[StrictStr], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered.")] = None,
    technical_tag: Annotated[Optional[StrictStr], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered.")] = None,
    not_in_run: Annotated[Optional[StrictStr], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictStr], Field(description="When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the list of bundle data.


    :param bundle_id: (required)
    :type bundle_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: str
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: str
    :param filename_match_mode: How the filenames are filtered.
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: str
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: str
    :param format_id: The IDs of the formats to filter on.
    :type format_id: str
    :param format_code: The codes of the formats to filter on.
    :type format_code: str
    :param type: The type to filter on.
    :type type: str
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: str
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: str
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: str
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: str
    :param status_date_before: The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: str
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: str
    :param user_tag_match_mode: How the usertags are filtered.
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: str
    :param run_input_tag_match_mode: How the runInputTags are filtered.
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: str
    :param run_output_tag_match_mode: How the runOutputTags are filtered.
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: str
    :param connector_tag_match_mode: How the connectorTags are filtered.
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: str
    :param technical_tag_match_mode: How the technicalTags are filtered.
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: str
    :param not_linked_to_sample: When set to true only date that is unlinked to a sample will be returned.  This filter implies a filter of type File.
    :type not_linked_to_sample: str
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_serialize(
        bundle_id=bundle_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the list of bundle data.

:param bundle_id: (required) :type bundle_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: str :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: str :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: str :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: str :param format_id: The IDs of the formats to filter on. :type format_id: str :param format_code: The codes of the formats to filter on. :type format_code: str :param type: The type to filter on. :type type: str :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: str :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: str :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: str :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: str :param status_date_before: The date before which the status has been updated Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: str :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: str :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: str :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: str :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: str :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: str :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: str :param not_linked_to_sample: When set to true only date that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: str :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_data_to_bundle(self,
bundle_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def link_data_to_bundle(
    self,
    bundle_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Link data to this bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_data_to_bundle_serialize(
        bundle_id=bundle_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Link data to this bundle.

:param bundle_id: (required) :type bundle_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_data_to_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def link_data_to_bundle_with_http_info(
    self,
    bundle_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Link data to this bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_data_to_bundle_serialize(
        bundle_id=bundle_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Link data to this bundle.

:param bundle_id: (required) :type bundle_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_data_to_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def link_data_to_bundle_without_preload_content(
    self,
    bundle_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Link data to this bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_data_to_bundle_serialize(
        bundle_id=bundle_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Link data to this bundle.

:param bundle_id: (required) :type bundle_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_data_from_bundle(self,
bundle_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def unlink_data_from_bundle(
    self,
    bundle_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Unlink data from this bundle.

    Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Bundle Data Unlinking Batch' for recursive unlinking.

    :param bundle_id: (required)
    :type bundle_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_data_from_bundle_serialize(
        bundle_id=bundle_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Unlink data from this bundle.

Note that for folders, this only unlinks the folder itself, not the folder contents! Use 'Bundle Data Unlinking Batch' for recursive unlinking.

:param bundle_id: (required) :type bundle_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_data_from_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unlink_data_from_bundle_with_http_info(
    self,
    bundle_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Unlink data from this bundle.

    Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Bundle Data Unlinking Batch' for recursive unlinking.

    :param bundle_id: (required)
    :type bundle_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_data_from_bundle_serialize(
        bundle_id=bundle_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Unlink data from this bundle.

Note that for folders, this only unlinks the folder itself, not the folder contents! Use 'Bundle Data Unlinking Batch' for recursive unlinking.

:param bundle_id: (required) :type bundle_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_data_from_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unlink_data_from_bundle_without_preload_content(
    self,
    bundle_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Unlink data from this bundle.

    Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Bundle Data Unlinking Batch' for recursive unlinking.

    :param bundle_id: (required)
    :type bundle_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_data_from_bundle_serialize(
        bundle_id=bundle_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Unlink data from this bundle.

Note that for folders, this only unlinks the folder itself, not the folder contents! Use 'Bundle Data Unlinking Batch' for recursive unlinking.

:param bundle_id: (required) :type bundle_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class BundleDataLinkingBatch (**data: Any)

Expand source code

class BundleDataLinkingBatch(BaseModel):
    """
    BundleDataLinkingBatch
    """ # noqa: E501
    id: StrictStr
    job: Optional[Job]
    __properties: ClassVar[List[str]] = ["id", "job"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of job
        if self.job:
            _dict['job'] = self.job.to_dict()
        # set to None if job (nullable) is None
        # and model_fields_set contains the field
        if self.job is None and "job" in self.model_fields_set:
            _dict['job'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "job": Job.from_dict(obj["job"]) if obj.get("job") is not None else None
        })
        return _obj

BundleDataLinkingBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var job : Job | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataLinkingBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataLinkingBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of job
    if self.job:
        _dict['job'] = self.job.to_dict()
    # set to None if job (nullable) is None
    # and model_fields_set contains the field
    if self.job is None and "job" in self.model_fields_set:
        _dict['job'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataLinkingBatchApi (api_client=None)

Expand source code

class BundleDataLinkingBatchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_bundle_data_linking_batch(
        self,
        bundle_id: StrictStr,
        create_bundle_data_linking_batch: CreateBundleDataLinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleDataLinkingBatch:
        """Create a bundle data linking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param create_bundle_data_linking_batch: (required)
        :type create_bundle_data_linking_batch: CreateBundleDataLinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_bundle_data_linking_batch_serialize(
            bundle_id=bundle_id,
            create_bundle_data_linking_batch=create_bundle_data_linking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "BundleDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_bundle_data_linking_batch_with_http_info(
        self,
        bundle_id: StrictStr,
        create_bundle_data_linking_batch: CreateBundleDataLinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleDataLinkingBatch]:
        """Create a bundle data linking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param create_bundle_data_linking_batch: (required)
        :type create_bundle_data_linking_batch: CreateBundleDataLinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_bundle_data_linking_batch_serialize(
            bundle_id=bundle_id,
            create_bundle_data_linking_batch=create_bundle_data_linking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "BundleDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_bundle_data_linking_batch_without_preload_content(
        self,
        bundle_id: StrictStr,
        create_bundle_data_linking_batch: CreateBundleDataLinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a bundle data linking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param create_bundle_data_linking_batch: (required)
        :type create_bundle_data_linking_batch: CreateBundleDataLinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_bundle_data_linking_batch_serialize(
            bundle_id=bundle_id,
            create_bundle_data_linking_batch=create_bundle_data_linking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "BundleDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_bundle_data_linking_batch_serialize(
        self,
        bundle_id,
        create_bundle_data_linking_batch,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_bundle_data_linking_batch is not None:
            _body_params = create_bundle_data_linking_batch


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}/dataLinkingBatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_bundle_data_linking_batch(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleDataLinkingBatch:
        """Retrieve a bundle data linking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_linking_batch_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_data_linking_batch_with_http_info(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleDataLinkingBatch]:
        """Retrieve a bundle data linking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_linking_batch_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_data_linking_batch_without_preload_content(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a bundle data linking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_linking_batch_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_data_linking_batch_serialize(
        self,
        bundle_id,
        batch_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/dataLinkingBatch/{batchId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_bundle_data_linking_batch_item(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleDataLinkingBatchItem:
        """Retrieve a bundle data linking batch item.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_linking_batch_item_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataLinkingBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_data_linking_batch_item_with_http_info(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleDataLinkingBatchItem]:
        """Retrieve a bundle data linking batch item.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_linking_batch_item_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataLinkingBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_data_linking_batch_item_without_preload_content(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a bundle data linking batch item.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_linking_batch_item_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataLinkingBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_data_linking_batch_item_serialize(
        self,
        bundle_id,
        batch_id,
        item_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        if item_id is not None:
            _path_params['itemId'] = item_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/dataLinkingBatch/{batchId}/items/{itemId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_bundle_data_linking_batch_items(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleDataLinkingBatchItemPagedList:
        """Retrieve a list of bundle data linking batch items.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_linking_batch_items_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataLinkingBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_data_linking_batch_items_with_http_info(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleDataLinkingBatchItemPagedList]:
        """Retrieve a list of bundle data linking batch items.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_linking_batch_items_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataLinkingBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_data_linking_batch_items_without_preload_content(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of bundle data linking batch items.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_linking_batch_items_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataLinkingBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_data_linking_batch_items_serialize(
        self,
        bundle_id,
        batch_id,
        status,
        page_offset,
        page_token,
        page_size,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/dataLinkingBatch/{batchId}/items',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_bundle_data_linking_batch(self,
bundle_id: Annotated[str, Strict(strict=True)],
create_bundle_data_linking_batch: CreateBundleDataLinkingBatch) ‑> BundleDataLinkingBatch

Expand source code

@validate_call
def create_bundle_data_linking_batch(
    self,
    bundle_id: StrictStr,
    create_bundle_data_linking_batch: CreateBundleDataLinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleDataLinkingBatch:
    """Create a bundle data linking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param create_bundle_data_linking_batch: (required)
    :type create_bundle_data_linking_batch: CreateBundleDataLinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_bundle_data_linking_batch_serialize(
        bundle_id=bundle_id,
        create_bundle_data_linking_batch=create_bundle_data_linking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "BundleDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a bundle data linking batch.

:param bundle_id: (required) :type bundle_id: str :param create_bundle_data_linking_batch: (required) :type create_bundle_data_linking_batch: CreateBundleDataLinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_bundle_data_linking_batch_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
create_bundle_data_linking_batch: CreateBundleDataLinkingBatch) ‑> ApiResponse[BundleDataLinkingBatch]

Expand source code

@validate_call
def create_bundle_data_linking_batch_with_http_info(
    self,
    bundle_id: StrictStr,
    create_bundle_data_linking_batch: CreateBundleDataLinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleDataLinkingBatch]:
    """Create a bundle data linking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param create_bundle_data_linking_batch: (required)
    :type create_bundle_data_linking_batch: CreateBundleDataLinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_bundle_data_linking_batch_serialize(
        bundle_id=bundle_id,
        create_bundle_data_linking_batch=create_bundle_data_linking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "BundleDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a bundle data linking batch.

:param bundle_id: (required) :type bundle_id: str :param create_bundle_data_linking_batch: (required) :type create_bundle_data_linking_batch: CreateBundleDataLinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_bundle_data_linking_batch_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
create_bundle_data_linking_batch: CreateBundleDataLinkingBatch) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_bundle_data_linking_batch_without_preload_content(
    self,
    bundle_id: StrictStr,
    create_bundle_data_linking_batch: CreateBundleDataLinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a bundle data linking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param create_bundle_data_linking_batch: (required)
    :type create_bundle_data_linking_batch: CreateBundleDataLinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_bundle_data_linking_batch_serialize(
        bundle_id=bundle_id,
        create_bundle_data_linking_batch=create_bundle_data_linking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "BundleDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a bundle data linking batch.

:param bundle_id: (required) :type bundle_id: str :param create_bundle_data_linking_batch: (required) :type create_bundle_data_linking_batch: CreateBundleDataLinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_linking_batch(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> BundleDataLinkingBatch

Expand source code

@validate_call
def get_bundle_data_linking_batch(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleDataLinkingBatch:
    """Retrieve a bundle data linking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_linking_batch_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a bundle data linking batch.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_linking_batch_item(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> BundleDataLinkingBatchItem

Expand source code

@validate_call
def get_bundle_data_linking_batch_item(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleDataLinkingBatchItem:
    """Retrieve a bundle data linking batch item.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_linking_batch_item_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataLinkingBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a bundle data linking batch item.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_linking_batch_item_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[BundleDataLinkingBatchItem]

Expand source code

@validate_call
def get_bundle_data_linking_batch_item_with_http_info(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleDataLinkingBatchItem]:
    """Retrieve a bundle data linking batch item.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_linking_batch_item_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataLinkingBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a bundle data linking batch item.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_linking_batch_item_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_data_linking_batch_item_without_preload_content(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a bundle data linking batch item.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_linking_batch_item_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataLinkingBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a bundle data linking batch item.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_linking_batch_items(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> BundleDataLinkingBatchItemPagedList

Expand source code

@validate_call
def get_bundle_data_linking_batch_items(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleDataLinkingBatchItemPagedList:
    """Retrieve a list of bundle data linking batch items.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_linking_batch_items_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataLinkingBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of bundle data linking batch items.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_linking_batch_items_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ApiResponse[BundleDataLinkingBatchItemPagedList]

Expand source code

@validate_call
def get_bundle_data_linking_batch_items_with_http_info(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleDataLinkingBatchItemPagedList]:
    """Retrieve a list of bundle data linking batch items.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_linking_batch_items_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataLinkingBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of bundle data linking batch items.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_linking_batch_items_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_data_linking_batch_items_without_preload_content(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of bundle data linking batch items.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_linking_batch_items_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataLinkingBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of bundle data linking batch items.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_linking_batch_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[BundleDataLinkingBatch]

Expand source code

@validate_call
def get_bundle_data_linking_batch_with_http_info(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleDataLinkingBatch]:
    """Retrieve a bundle data linking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_linking_batch_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a bundle data linking batch.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_linking_batch_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_data_linking_batch_without_preload_content(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a bundle data linking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_linking_batch_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a bundle data linking batch.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class BundleDataLinkingBatchItem (**data: Any)

Expand source code

class BundleDataLinkingBatchItem(BaseModel):
    """
    BundleDataLinkingBatchItem
    """ # noqa: E501
    id: StrictStr
    request: BundleDataLinkingBatchItemRequest
    processing: BundleDataLinkingBatchItemProcessing
    bundle_data: Optional[BundleData] = Field(default=None, alias="bundleData")
    __properties: ClassVar[List[str]] = ["id", "request", "processing", "bundleData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        # override the default output from pydantic by calling `to_dict()` of bundle_data
        if self.bundle_data:
            _dict['bundleData'] = self.bundle_data.to_dict()
        # set to None if bundle_data (nullable) is None
        # and model_fields_set contains the field
        if self.bundle_data is None and "bundle_data" in self.model_fields_set:
            _dict['bundleData'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": BundleDataLinkingBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": BundleDataLinkingBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None,
            "bundleData": BundleData.from_dict(obj["bundleData"]) if obj.get("bundleData") is not None else None
        })
        return _obj

BundleDataLinkingBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bundle_data : BundleData | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : BundleDataLinkingBatchItemProcessing

The type of the None singleton.

var request : BundleDataLinkingBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataLinkingBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataLinkingBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    # override the default output from pydantic by calling `to_dict()` of bundle_data
    if self.bundle_data:
        _dict['bundleData'] = self.bundle_data.to_dict()
    # set to None if bundle_data (nullable) is None
    # and model_fields_set contains the field
    if self.bundle_data is None and "bundle_data" in self.model_fields_set:
        _dict['bundleData'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataLinkingBatchItemPagedList (**data: Any)

Expand source code

class BundleDataLinkingBatchItemPagedList(BaseModel):
    """
    BundleDataLinkingBatchItemPagedList
    """ # noqa: E501
    items: List[BundleDataLinkingBatchItem]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatchItemPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatchItemPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [BundleDataLinkingBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

BundleDataLinkingBatchItemPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[BundleDataLinkingBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataLinkingBatchItemPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataLinkingBatchItemPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataLinkingBatchItemProcessing (**data: Any)

Expand source code

class BundleDataLinkingBatchItemProcessing(BaseModel):
    """
    BundleDataLinkingBatchItemProcessing
    """ # noqa: E501
    status: StrictStr = Field(description="Possible values are: INITIALISED, WAITING_RESOURCES, RUNNING, LINKED, ALREADY_LINKED, FAILED, PARTIALLY_LINKED. More types could be added in a future release.")
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatchItemProcessing from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatchItemProcessing from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

BundleDataLinkingBatchItemProcessing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataLinkingBatchItemProcessing from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataLinkingBatchItemProcessing from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataLinkingBatchItemRequest (**data: Any)

Expand source code

class BundleDataLinkingBatchItemRequest(BaseModel):
    """
    BundleDataLinkingBatchItemRequest
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatchItemRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataLinkingBatchItemRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

BundleDataLinkingBatchItemRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataLinkingBatchItemRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataLinkingBatchItemRequest from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataPagedList (**data: Any)

Expand source code

class BundleDataPagedList(BaseModel):
    """
    BundleDataPagedList
    """ # noqa: E501
    items: List[Optional[BundleData]]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [BundleData.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

BundleDataPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[BundleData | None]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataUnlinkingBatch (**data: Any)

Expand source code

class BundleDataUnlinkingBatch(BaseModel):
    """
    BundleDataUnlinkingBatch
    """ # noqa: E501
    id: StrictStr
    job: Optional[Job]
    __properties: ClassVar[List[str]] = ["id", "job"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of job
        if self.job:
            _dict['job'] = self.job.to_dict()
        # set to None if job (nullable) is None
        # and model_fields_set contains the field
        if self.job is None and "job" in self.model_fields_set:
            _dict['job'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "job": Job.from_dict(obj["job"]) if obj.get("job") is not None else None
        })
        return _obj

BundleDataUnlinkingBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var job : Job | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataUnlinkingBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataUnlinkingBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of job
    if self.job:
        _dict['job'] = self.job.to_dict()
    # set to None if job (nullable) is None
    # and model_fields_set contains the field
    if self.job is None and "job" in self.model_fields_set:
        _dict['job'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataUnlinkingBatchApi (api_client=None)

Expand source code

class BundleDataUnlinkingBatchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_bundle_data_unlinking_batch(
        self,
        bundle_id: StrictStr,
        create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleDataUnlinkingBatch:
        """Create a bundle data unlinking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param create_bundle_data_unlinking_batch: (required)
        :type create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_bundle_data_unlinking_batch_serialize(
            bundle_id=bundle_id,
            create_bundle_data_unlinking_batch=create_bundle_data_unlinking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "BundleDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_bundle_data_unlinking_batch_with_http_info(
        self,
        bundle_id: StrictStr,
        create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleDataUnlinkingBatch]:
        """Create a bundle data unlinking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param create_bundle_data_unlinking_batch: (required)
        :type create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_bundle_data_unlinking_batch_serialize(
            bundle_id=bundle_id,
            create_bundle_data_unlinking_batch=create_bundle_data_unlinking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "BundleDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_bundle_data_unlinking_batch_without_preload_content(
        self,
        bundle_id: StrictStr,
        create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a bundle data unlinking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param create_bundle_data_unlinking_batch: (required)
        :type create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_bundle_data_unlinking_batch_serialize(
            bundle_id=bundle_id,
            create_bundle_data_unlinking_batch=create_bundle_data_unlinking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "BundleDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_bundle_data_unlinking_batch_serialize(
        self,
        bundle_id,
        create_bundle_data_unlinking_batch,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_bundle_data_unlinking_batch is not None:
            _body_params = create_bundle_data_unlinking_batch


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}/dataUnlinkingBatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_bundle_data_unlinking_batch(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleDataUnlinkingBatch:
        """Retrieve a bundle data unlinking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_unlinking_batch_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_data_unlinking_batch_with_http_info(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleDataUnlinkingBatch]:
        """Retrieve a bundle data unlinking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_unlinking_batch_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_data_unlinking_batch_without_preload_content(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a bundle data unlinking batch.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_unlinking_batch_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_data_unlinking_batch_serialize(
        self,
        bundle_id,
        batch_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/dataUnlinkingBatch/{batchId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_bundle_data_unlinking_batch_item(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleDataUnlinkingBatchItem:
        """Retrieve a bundle data unlinking batch item.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_unlinking_batch_item_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataUnlinkingBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_data_unlinking_batch_item_with_http_info(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleDataUnlinkingBatchItem]:
        """Retrieve a bundle data unlinking batch item.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_unlinking_batch_item_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataUnlinkingBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_data_unlinking_batch_item_without_preload_content(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a bundle data unlinking batch item.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_unlinking_batch_item_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataUnlinkingBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_data_unlinking_batch_item_serialize(
        self,
        bundle_id,
        batch_id,
        item_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        if item_id is not None:
            _path_params['itemId'] = item_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/dataUnlinkingBatch/{batchId}/items/{itemId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_bundle_data_unlinking_batch_items(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleDataUnlinkingBatchItemPagedList:
        """Retrieve a list of bundle data unlinking batch items.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_unlinking_batch_items_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataUnlinkingBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_data_unlinking_batch_items_with_http_info(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleDataUnlinkingBatchItemPagedList]:
        """Retrieve a list of bundle data unlinking batch items.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_unlinking_batch_items_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataUnlinkingBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_data_unlinking_batch_items_without_preload_content(
        self,
        bundle_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of bundle data unlinking batch items.


        :param bundle_id: (required)
        :type bundle_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_data_unlinking_batch_items_serialize(
            bundle_id=bundle_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleDataUnlinkingBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_data_unlinking_batch_items_serialize(
        self,
        bundle_id,
        batch_id,
        status,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/dataUnlinkingBatch/{batchId}/items',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_bundle_data_unlinking_batch(self,
bundle_id: Annotated[str, Strict(strict=True)],
create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch) ‑> BundleDataUnlinkingBatch

Expand source code

@validate_call
def create_bundle_data_unlinking_batch(
    self,
    bundle_id: StrictStr,
    create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleDataUnlinkingBatch:
    """Create a bundle data unlinking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param create_bundle_data_unlinking_batch: (required)
    :type create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_bundle_data_unlinking_batch_serialize(
        bundle_id=bundle_id,
        create_bundle_data_unlinking_batch=create_bundle_data_unlinking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "BundleDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a bundle data unlinking batch.

:param bundle_id: (required) :type bundle_id: str :param create_bundle_data_unlinking_batch: (required) :type create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_bundle_data_unlinking_batch_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch) ‑> ApiResponse[BundleDataUnlinkingBatch]

Expand source code

@validate_call
def create_bundle_data_unlinking_batch_with_http_info(
    self,
    bundle_id: StrictStr,
    create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleDataUnlinkingBatch]:
    """Create a bundle data unlinking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param create_bundle_data_unlinking_batch: (required)
    :type create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_bundle_data_unlinking_batch_serialize(
        bundle_id=bundle_id,
        create_bundle_data_unlinking_batch=create_bundle_data_unlinking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "BundleDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a bundle data unlinking batch.

:param bundle_id: (required) :type bundle_id: str :param create_bundle_data_unlinking_batch: (required) :type create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_bundle_data_unlinking_batch_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_bundle_data_unlinking_batch_without_preload_content(
    self,
    bundle_id: StrictStr,
    create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a bundle data unlinking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param create_bundle_data_unlinking_batch: (required)
    :type create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_bundle_data_unlinking_batch_serialize(
        bundle_id=bundle_id,
        create_bundle_data_unlinking_batch=create_bundle_data_unlinking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "BundleDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a bundle data unlinking batch.

:param bundle_id: (required) :type bundle_id: str :param create_bundle_data_unlinking_batch: (required) :type create_bundle_data_unlinking_batch: CreateBundleDataUnlinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_unlinking_batch(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> BundleDataUnlinkingBatch

Expand source code

@validate_call
def get_bundle_data_unlinking_batch(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleDataUnlinkingBatch:
    """Retrieve a bundle data unlinking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_unlinking_batch_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a bundle data unlinking batch.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_unlinking_batch_item(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> BundleDataUnlinkingBatchItem

Expand source code

@validate_call
def get_bundle_data_unlinking_batch_item(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleDataUnlinkingBatchItem:
    """Retrieve a bundle data unlinking batch item.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_unlinking_batch_item_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataUnlinkingBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a bundle data unlinking batch item.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_unlinking_batch_item_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[BundleDataUnlinkingBatchItem]

Expand source code

@validate_call
def get_bundle_data_unlinking_batch_item_with_http_info(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleDataUnlinkingBatchItem]:
    """Retrieve a bundle data unlinking batch item.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_unlinking_batch_item_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataUnlinkingBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a bundle data unlinking batch item.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_unlinking_batch_item_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_data_unlinking_batch_item_without_preload_content(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a bundle data unlinking batch item.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_unlinking_batch_item_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataUnlinkingBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a bundle data unlinking batch item.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_unlinking_batch_items(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc"')] = None) ‑> BundleDataUnlinkingBatchItemPagedList

Expand source code

@validate_call
def get_bundle_data_unlinking_batch_items(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleDataUnlinkingBatchItemPagedList:
    """Retrieve a list of bundle data unlinking batch items.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_unlinking_batch_items_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataUnlinkingBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of bundle data unlinking batch items.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_unlinking_batch_items_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc"')] = None) ‑> ApiResponse[BundleDataUnlinkingBatchItemPagedList]

Expand source code

@validate_call
def get_bundle_data_unlinking_batch_items_with_http_info(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleDataUnlinkingBatchItemPagedList]:
    """Retrieve a list of bundle data unlinking batch items.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_unlinking_batch_items_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataUnlinkingBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of bundle data unlinking batch items.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_unlinking_batch_items_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc"')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_data_unlinking_batch_items_without_preload_content(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of bundle data unlinking batch items.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_unlinking_batch_items_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataUnlinkingBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of bundle data unlinking batch items.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_unlinking_batch_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[BundleDataUnlinkingBatch]

Expand source code

@validate_call
def get_bundle_data_unlinking_batch_with_http_info(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleDataUnlinkingBatch]:
    """Retrieve a bundle data unlinking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_unlinking_batch_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a bundle data unlinking batch.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_data_unlinking_batch_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_data_unlinking_batch_without_preload_content(
    self,
    bundle_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a bundle data unlinking batch.


    :param bundle_id: (required)
    :type bundle_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_data_unlinking_batch_serialize(
        bundle_id=bundle_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a bundle data unlinking batch.

:param bundle_id: (required) :type bundle_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class BundleDataUnlinkingBatchItem (**data: Any)

Expand source code

class BundleDataUnlinkingBatchItem(BaseModel):
    """
    BundleDataUnlinkingBatchItem
    """ # noqa: E501
    id: StrictStr
    request: BundleDataUnlinkingBatchItemRequest
    processing: BundleDataUnlinkingBatchItemProcessing
    __properties: ClassVar[List[str]] = ["id", "request", "processing"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": BundleDataUnlinkingBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": BundleDataUnlinkingBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None
        })
        return _obj

BundleDataUnlinkingBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : BundleDataUnlinkingBatchItemProcessing

The type of the None singleton.

var request : BundleDataUnlinkingBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataUnlinkingBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataUnlinkingBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataUnlinkingBatchItemPagedList (**data: Any)

Expand source code

class BundleDataUnlinkingBatchItemPagedList(BaseModel):
    """
    BundleDataUnlinkingBatchItemPagedList
    """ # noqa: E501
    items: List[BundleDataUnlinkingBatchItem]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatchItemPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatchItemPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [BundleDataUnlinkingBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

BundleDataUnlinkingBatchItemPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[BundleDataUnlinkingBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataUnlinkingBatchItemPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataUnlinkingBatchItemPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataUnlinkingBatchItemProcessing (**data: Any)

Expand source code

class BundleDataUnlinkingBatchItemProcessing(BaseModel):
    """
    BundleDataUnlinkingBatchItemProcessing
    """ # noqa: E501
    status: StrictStr = Field(description="Possible values are: INITIALISED, WAITING_RESOURCES, RUNNING, UNLINKED, ALREADY_UNLINKED, FAILED, PARTIALLY_UNLINKED. More types could be added in a future release.")
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatchItemProcessing from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatchItemProcessing from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

BundleDataUnlinkingBatchItemProcessing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataUnlinkingBatchItemProcessing from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataUnlinkingBatchItemProcessing from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleDataUnlinkingBatchItemRequest (**data: Any)

Expand source code

class BundleDataUnlinkingBatchItemRequest(BaseModel):
    """
    BundleDataUnlinkingBatchItemRequest
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatchItemRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleDataUnlinkingBatchItemRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

BundleDataUnlinkingBatchItemRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleDataUnlinkingBatchItemRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleDataUnlinkingBatchItemRequest from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleList (**data: Any)

Expand source code

class BundleList(BaseModel):
    """
    BundleList
    """ # noqa: E501
    items: List[Optional[Bundle]]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Bundle.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

BundleList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Bundle | None]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundlePagedList (**data: Any)

Expand source code

class BundlePagedList(BaseModel):
    """
    BundlePagedList
    """ # noqa: E501
    items: List[Optional[Bundle]]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundlePagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundlePagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Bundle.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

BundlePagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Bundle | None]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundlePagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundlePagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundlePipeline (**data: Any)

Expand source code

class BundlePipeline(BaseModel):
    """
    BundlePipeline
    """ # noqa: E501
    pipeline: PipelineV3
    bundle_id: StrictStr = Field(alias="bundleId")
    __properties: ClassVar[List[str]] = ["pipeline", "bundleId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundlePipeline from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of pipeline
        if self.pipeline:
            _dict['pipeline'] = self.pipeline.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundlePipeline from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "pipeline": PipelineV3.from_dict(obj["pipeline"]) if obj.get("pipeline") is not None else None,
            "bundleId": obj.get("bundleId")
        })
        return _obj

BundlePipeline

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bundle_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var pipeline : PipelineV3

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundlePipeline from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundlePipeline from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of pipeline
    if self.pipeline:
        _dict['pipeline'] = self.pipeline.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundlePipelineApi (api_client=None)

Expand source code

class BundlePipelineApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_bundle_pipelines(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve pipelines for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundlePipelineList:
        """Retrieve a list of bundle pipelines.


        :param bundle_id: The ID of the bundle to retrieve pipelines for (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_pipelines_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundlePipelineList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_pipelines_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve pipelines for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundlePipelineList]:
        """Retrieve a list of bundle pipelines.


        :param bundle_id: The ID of the bundle to retrieve pipelines for (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_pipelines_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundlePipelineList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_pipelines_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve pipelines for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of bundle pipelines.


        :param bundle_id: The ID of the bundle to retrieve pipelines for (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_pipelines_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundlePipelineList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_pipelines_serialize(
        self,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/pipelines',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def link_pipeline_to_bundle(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Link a pipeline to a bundle.


        :param bundle_id: The ID of the bundle (required)
        :type bundle_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_pipeline_to_bundle_serialize(
            bundle_id=bundle_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def link_pipeline_to_bundle_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Link a pipeline to a bundle.


        :param bundle_id: The ID of the bundle (required)
        :type bundle_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_pipeline_to_bundle_serialize(
            bundle_id=bundle_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def link_pipeline_to_bundle_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Link a pipeline to a bundle.


        :param bundle_id: The ID of the bundle (required)
        :type bundle_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_pipeline_to_bundle_serialize(
            bundle_id=bundle_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _link_pipeline_to_bundle_serialize(
        self,
        bundle_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}/pipelines/{pipelineId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unlink_pipeline_from_bundle(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Unlink a pipeline from a bundle.


        :param bundle_id: The ID of the bundle (required)
        :type bundle_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_pipeline_from_bundle_serialize(
            bundle_id=bundle_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unlink_pipeline_from_bundle_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Unlink a pipeline from a bundle.


        :param bundle_id: The ID of the bundle (required)
        :type bundle_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_pipeline_from_bundle_serialize(
            bundle_id=bundle_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unlink_pipeline_from_bundle_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Unlink a pipeline from a bundle.


        :param bundle_id: The ID of the bundle (required)
        :type bundle_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_pipeline_from_bundle_serialize(
            bundle_id=bundle_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unlink_pipeline_from_bundle_serialize(
        self,
        bundle_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/bundles/{bundleId}/pipelines/{pipelineId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_bundle_pipelines(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to retrieve pipelines for')]) ‑> BundlePipelineList

Expand source code

@validate_call
def get_bundle_pipelines(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve pipelines for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundlePipelineList:
    """Retrieve a list of bundle pipelines.


    :param bundle_id: The ID of the bundle to retrieve pipelines for (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_pipelines_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundlePipelineList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of bundle pipelines.

:param bundle_id: The ID of the bundle to retrieve pipelines for (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_pipelines_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to retrieve pipelines for')]) ‑> ApiResponse[BundlePipelineList]

Expand source code

@validate_call
def get_bundle_pipelines_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve pipelines for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundlePipelineList]:
    """Retrieve a list of bundle pipelines.


    :param bundle_id: The ID of the bundle to retrieve pipelines for (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_pipelines_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundlePipelineList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of bundle pipelines.

:param bundle_id: The ID of the bundle to retrieve pipelines for (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_pipelines_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to retrieve pipelines for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_pipelines_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to retrieve pipelines for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of bundle pipelines.


    :param bundle_id: The ID of the bundle to retrieve pipelines for (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_pipelines_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundlePipelineList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of bundle pipelines.

:param bundle_id: The ID of the bundle to retrieve pipelines for (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_pipeline_to_bundle(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle')],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> None

Expand source code

@validate_call
def link_pipeline_to_bundle(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Link a pipeline to a bundle.


    :param bundle_id: The ID of the bundle (required)
    :type bundle_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_pipeline_to_bundle_serialize(
        bundle_id=bundle_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Link a pipeline to a bundle.

:param bundle_id: The ID of the bundle (required) :type bundle_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_pipeline_to_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle')],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def link_pipeline_to_bundle_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Link a pipeline to a bundle.


    :param bundle_id: The ID of the bundle (required)
    :type bundle_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_pipeline_to_bundle_serialize(
        bundle_id=bundle_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Link a pipeline to a bundle.

:param bundle_id: The ID of the bundle (required) :type bundle_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_pipeline_to_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle')],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def link_pipeline_to_bundle_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Link a pipeline to a bundle.


    :param bundle_id: The ID of the bundle (required)
    :type bundle_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_pipeline_to_bundle_serialize(
        bundle_id=bundle_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Link a pipeline to a bundle.

:param bundle_id: The ID of the bundle (required) :type bundle_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_pipeline_from_bundle(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle')],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> None

Expand source code

@validate_call
def unlink_pipeline_from_bundle(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Unlink a pipeline from a bundle.


    :param bundle_id: The ID of the bundle (required)
    :type bundle_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_pipeline_from_bundle_serialize(
        bundle_id=bundle_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Unlink a pipeline from a bundle.

:param bundle_id: The ID of the bundle (required) :type bundle_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_pipeline_from_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle')],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unlink_pipeline_from_bundle_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Unlink a pipeline from a bundle.


    :param bundle_id: The ID of the bundle (required)
    :type bundle_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_pipeline_from_bundle_serialize(
        bundle_id=bundle_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Unlink a pipeline from a bundle.

:param bundle_id: The ID of the bundle (required) :type bundle_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_pipeline_from_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle')],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unlink_pipeline_from_bundle_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle")],
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Unlink a pipeline from a bundle.


    :param bundle_id: The ID of the bundle (required)
    :type bundle_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_pipeline_from_bundle_serialize(
        bundle_id=bundle_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Unlink a pipeline from a bundle.

:param bundle_id: The ID of the bundle (required) :type bundle_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class BundlePipelineList (**data: Any)

Expand source code

class BundlePipelineList(BaseModel):
    """
    BundlePipelineList
    """ # noqa: E501
    items: List[BundlePipeline]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundlePipelineList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundlePipelineList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [BundlePipeline.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

BundlePipelineList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[BundlePipeline]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundlePipelineList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundlePipelineList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleSample (**data: Any)

Expand source code

class BundleSample(BaseModel):
    """
    BundleSample
    """ # noqa: E501
    sample: Sample
    bundle_id: StrictStr = Field(alias="bundleId")
    __properties: ClassVar[List[str]] = ["sample", "bundleId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleSample from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of sample
        if self.sample:
            _dict['sample'] = self.sample.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleSample from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "sample": Sample.from_dict(obj["sample"]) if obj.get("sample") is not None else None,
            "bundleId": obj.get("bundleId")
        })
        return _obj

BundleSample

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bundle_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var sample : Sample

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleSample from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleSample from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of sample
    if self.sample:
        _dict['sample'] = self.sample.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleSampleApi (api_client=None)

Expand source code

class BundleSampleApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_bundle_samples(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get bundle samples from")],
        search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleSamplePagedList:
        """Retrieve a list of bundle samples.


        :param bundle_id: The ID of the bundle to get bundle samples from (required)
        :type bundle_id: str
        :param search: To search through multiple fields of data.
        :type search: str
        :param user_tags: The user tags to filter on.
        :type user_tags: str
        :param technical_tags: The technical tags to filter on.
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_samples_serialize(
            bundle_id=bundle_id,
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleSamplePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_samples_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get bundle samples from")],
        search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleSamplePagedList]:
        """Retrieve a list of bundle samples.


        :param bundle_id: The ID of the bundle to get bundle samples from (required)
        :type bundle_id: str
        :param search: To search through multiple fields of data.
        :type search: str
        :param user_tags: The user tags to filter on.
        :type user_tags: str
        :param technical_tags: The technical tags to filter on.
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_samples_serialize(
            bundle_id=bundle_id,
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleSamplePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_samples_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get bundle samples from")],
        search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of bundle samples.


        :param bundle_id: The ID of the bundle to get bundle samples from (required)
        :type bundle_id: str
        :param search: To search through multiple fields of data.
        :type search: str
        :param user_tags: The user tags to filter on.
        :type user_tags: str
        :param technical_tags: The technical tags to filter on.
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_samples_serialize(
            bundle_id=bundle_id,
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleSamplePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_samples_serialize(
        self,
        bundle_id,
        search,
        user_tags,
        technical_tags,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        if search is not None:
            
            _query_params.append(('search', search))
            
        if user_tags is not None:
            
            _query_params.append(('userTags', user_tags))
            
        if technical_tags is not None:
            
            _query_params.append(('technicalTags', technical_tags))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/samples',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def link_sample_to_bundle(
        self,
        bundle_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Link a sample to a bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_sample_to_bundle_serialize(
            bundle_id=bundle_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def link_sample_to_bundle_with_http_info(
        self,
        bundle_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Link a sample to a bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_sample_to_bundle_serialize(
            bundle_id=bundle_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def link_sample_to_bundle_without_preload_content(
        self,
        bundle_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Link a sample to a bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_sample_to_bundle_serialize(
            bundle_id=bundle_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _link_sample_to_bundle_serialize(
        self,
        bundle_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}/samples/{sampleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unlink_sample_from_bundle(
        self,
        bundle_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Unlink a sample from a bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_sample_from_bundle_serialize(
            bundle_id=bundle_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unlink_sample_from_bundle_with_http_info(
        self,
        bundle_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Unlink a sample from a bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_sample_from_bundle_serialize(
            bundle_id=bundle_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unlink_sample_from_bundle_without_preload_content(
        self,
        bundle_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Unlink a sample from a bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_sample_from_bundle_serialize(
            bundle_id=bundle_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unlink_sample_from_bundle_serialize(
        self,
        bundle_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/bundles/{bundleId}/samples/{sampleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_bundle_samples(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to get bundle samples from')],
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user tags to filter on.')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status')] = None) ‑> BundleSamplePagedList

Expand source code

@validate_call
def get_bundle_samples(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get bundle samples from")],
    search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleSamplePagedList:
    """Retrieve a list of bundle samples.


    :param bundle_id: The ID of the bundle to get bundle samples from (required)
    :type bundle_id: str
    :param search: To search through multiple fields of data.
    :type search: str
    :param user_tags: The user tags to filter on.
    :type user_tags: str
    :param technical_tags: The technical tags to filter on.
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_samples_serialize(
        bundle_id=bundle_id,
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleSamplePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of bundle samples.

:param bundle_id: The ID of the bundle to get bundle samples from (required) :type bundle_id: str :param search: To search through multiple fields of data. :type search: str :param user_tags: The user tags to filter on. :type user_tags: str :param technical_tags: The technical tags to filter on. :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_samples_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to get bundle samples from')],
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user tags to filter on.')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status')] = None) ‑> ApiResponse[BundleSamplePagedList]

Expand source code

@validate_call
def get_bundle_samples_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get bundle samples from")],
    search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleSamplePagedList]:
    """Retrieve a list of bundle samples.


    :param bundle_id: The ID of the bundle to get bundle samples from (required)
    :type bundle_id: str
    :param search: To search through multiple fields of data.
    :type search: str
    :param user_tags: The user tags to filter on.
    :type user_tags: str
    :param technical_tags: The technical tags to filter on.
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_samples_serialize(
        bundle_id=bundle_id,
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleSamplePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of bundle samples.

:param bundle_id: The ID of the bundle to get bundle samples from (required) :type bundle_id: str :param search: To search through multiple fields of data. :type search: str :param user_tags: The user tags to filter on. :type user_tags: str :param technical_tags: The technical tags to filter on. :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_samples_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to get bundle samples from')],
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user tags to filter on.')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_samples_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get bundle samples from")],
    search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of bundle samples.


    :param bundle_id: The ID of the bundle to get bundle samples from (required)
    :type bundle_id: str
    :param search: To search through multiple fields of data.
    :type search: str
    :param user_tags: The user tags to filter on.
    :type user_tags: str
    :param technical_tags: The technical tags to filter on.
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_samples_serialize(
        bundle_id=bundle_id,
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleSamplePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of bundle samples.

:param bundle_id: The ID of the bundle to get bundle samples from (required) :type bundle_id: str :param search: To search through multiple fields of data. :type search: str :param user_tags: The user tags to filter on. :type user_tags: str :param technical_tags: The technical tags to filter on. :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_sample_to_bundle(self,
bundle_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def link_sample_to_bundle(
    self,
    bundle_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Link a sample to a bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_sample_to_bundle_serialize(
        bundle_id=bundle_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Link a sample to a bundle.

:param bundle_id: (required) :type bundle_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_sample_to_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def link_sample_to_bundle_with_http_info(
    self,
    bundle_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Link a sample to a bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_sample_to_bundle_serialize(
        bundle_id=bundle_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Link a sample to a bundle.

:param bundle_id: (required) :type bundle_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_sample_to_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def link_sample_to_bundle_without_preload_content(
    self,
    bundle_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Link a sample to a bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_sample_to_bundle_serialize(
        bundle_id=bundle_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Link a sample to a bundle.

:param bundle_id: (required) :type bundle_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_sample_from_bundle(self,
bundle_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def unlink_sample_from_bundle(
    self,
    bundle_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Unlink a sample from a bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_sample_from_bundle_serialize(
        bundle_id=bundle_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Unlink a sample from a bundle.

:param bundle_id: (required) :type bundle_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_sample_from_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unlink_sample_from_bundle_with_http_info(
    self,
    bundle_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Unlink a sample from a bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_sample_from_bundle_serialize(
        bundle_id=bundle_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Unlink a sample from a bundle.

:param bundle_id: (required) :type bundle_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_sample_from_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unlink_sample_from_bundle_without_preload_content(
    self,
    bundle_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Unlink a sample from a bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_sample_from_bundle_serialize(
        bundle_id=bundle_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Unlink a sample from a bundle.

:param bundle_id: (required) :type bundle_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class BundleSamplePagedList (**data: Any)

Expand source code

class BundleSamplePagedList(BaseModel):
    """
    BundleSamplePagedList
    """ # noqa: E501
    items: List[BundleSample]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleSamplePagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleSamplePagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [BundleSample.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

BundleSamplePagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[BundleSample]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleSamplePagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleSamplePagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleTool (**data: Any)

Expand source code

class BundleTool(BaseModel):
    """
    BundleTool
    """ # noqa: E501
    cwl_tool_definition: CWLToolDefinition = Field(alias="cwlToolDefinition")
    __properties: ClassVar[List[str]] = ["cwlToolDefinition"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleTool from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of cwl_tool_definition
        if self.cwl_tool_definition:
            _dict['cwlToolDefinition'] = self.cwl_tool_definition.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleTool from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "cwlToolDefinition": CWLToolDefinition.from_dict(obj["cwlToolDefinition"]) if obj.get("cwlToolDefinition") is not None else None
        })
        return _obj

BundleTool

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var cwl_tool_definition : CWLToolDefinition

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleTool from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleTool from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of cwl_tool_definition
    if self.cwl_tool_definition:
        _dict['cwlToolDefinition'] = self.cwl_tool_definition.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class BundleToolApi (api_client=None)

Expand source code

class BundleToolApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_bundle_tools(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get tools from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundleToolsList:
        """Retrieve a list of bundle tools.


        :param bundle_id: The ID of the bundle to get tools from (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_tools_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleToolsList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_bundle_tools_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get tools from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundleToolsList]:
        """Retrieve a list of bundle tools.


        :param bundle_id: The ID of the bundle to get tools from (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_tools_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleToolsList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_bundle_tools_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get tools from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of bundle tools.


        :param bundle_id: The ID of the bundle to get tools from (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_bundle_tools_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundleToolsList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_bundle_tools_serialize(
        self,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/tools',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_tools_eligible_for_linking_to_bundle(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get the eligible tools for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> CwlToolDefinitionList:
        """Retrieve a list of tools eligible for linking to the bundle.


        :param bundle_id: The ID of the bundle to get the eligible tools for (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_tools_eligible_for_linking_to_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CwlToolDefinitionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_tools_eligible_for_linking_to_bundle_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get the eligible tools for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[CwlToolDefinitionList]:
        """Retrieve a list of tools eligible for linking to the bundle.


        :param bundle_id: The ID of the bundle to get the eligible tools for (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_tools_eligible_for_linking_to_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CwlToolDefinitionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_tools_eligible_for_linking_to_bundle_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get the eligible tools for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of tools eligible for linking to the bundle.


        :param bundle_id: The ID of the bundle to get the eligible tools for (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_tools_eligible_for_linking_to_bundle_serialize(
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CwlToolDefinitionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_tools_eligible_for_linking_to_bundle_serialize(
        self,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/bundles/{bundleId}/tools/eligibleForLinking',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def link_tool_to_bundle(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to link the tool to")],
        tool_id: Annotated[StrictStr, Field(description="The ID of the tool to link")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Link a tool to a bundle


        :param bundle_id: The ID of the bundle to link the tool to (required)
        :type bundle_id: str
        :param tool_id: The ID of the tool to link (required)
        :type tool_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_tool_to_bundle_serialize(
            bundle_id=bundle_id,
            tool_id=tool_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def link_tool_to_bundle_with_http_info(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to link the tool to")],
        tool_id: Annotated[StrictStr, Field(description="The ID of the tool to link")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Link a tool to a bundle


        :param bundle_id: The ID of the bundle to link the tool to (required)
        :type bundle_id: str
        :param tool_id: The ID of the tool to link (required)
        :type tool_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_tool_to_bundle_serialize(
            bundle_id=bundle_id,
            tool_id=tool_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def link_tool_to_bundle_without_preload_content(
        self,
        bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to link the tool to")],
        tool_id: Annotated[StrictStr, Field(description="The ID of the tool to link")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Link a tool to a bundle


        :param bundle_id: The ID of the bundle to link the tool to (required)
        :type bundle_id: str
        :param tool_id: The ID of the tool to link (required)
        :type tool_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_tool_to_bundle_serialize(
            bundle_id=bundle_id,
            tool_id=tool_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _link_tool_to_bundle_serialize(
        self,
        bundle_id,
        tool_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if tool_id is not None:
            _path_params['toolId'] = tool_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/bundles/{bundleId}/tools/{toolId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unlink_tool_from_bundle(
        self,
        bundle_id: StrictStr,
        tool_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Unlink a tool from this bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param tool_id: (required)
        :type tool_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_tool_from_bundle_serialize(
            bundle_id=bundle_id,
            tool_id=tool_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unlink_tool_from_bundle_with_http_info(
        self,
        bundle_id: StrictStr,
        tool_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Unlink a tool from this bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param tool_id: (required)
        :type tool_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_tool_from_bundle_serialize(
            bundle_id=bundle_id,
            tool_id=tool_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unlink_tool_from_bundle_without_preload_content(
        self,
        bundle_id: StrictStr,
        tool_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Unlink a tool from this bundle.


        :param bundle_id: (required)
        :type bundle_id: str
        :param tool_id: (required)
        :type tool_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_tool_from_bundle_serialize(
            bundle_id=bundle_id,
            tool_id=tool_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unlink_tool_from_bundle_serialize(
        self,
        bundle_id,
        tool_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        if tool_id is not None:
            _path_params['toolId'] = tool_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/bundles/{bundleId}/tools/{toolId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_bundle_tools(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to get tools from')]) ‑> BundleToolsList

Expand source code

@validate_call
def get_bundle_tools(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get tools from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundleToolsList:
    """Retrieve a list of bundle tools.


    :param bundle_id: The ID of the bundle to get tools from (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_tools_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleToolsList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of bundle tools.

:param bundle_id: The ID of the bundle to get tools from (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_tools_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to get tools from')]) ‑> ApiResponse[BundleToolsList]

Expand source code

@validate_call
def get_bundle_tools_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get tools from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundleToolsList]:
    """Retrieve a list of bundle tools.


    :param bundle_id: The ID of the bundle to get tools from (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_tools_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleToolsList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of bundle tools.

:param bundle_id: The ID of the bundle to get tools from (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_bundle_tools_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to get tools from')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_bundle_tools_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get tools from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of bundle tools.


    :param bundle_id: The ID of the bundle to get tools from (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_bundle_tools_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundleToolsList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of bundle tools.

:param bundle_id: The ID of the bundle to get tools from (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_tools_eligible_for_linking_to_bundle(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to get the eligible tools for')]) ‑> CwlToolDefinitionList

Expand source code

@validate_call
def get_tools_eligible_for_linking_to_bundle(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get the eligible tools for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> CwlToolDefinitionList:
    """Retrieve a list of tools eligible for linking to the bundle.


    :param bundle_id: The ID of the bundle to get the eligible tools for (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_tools_eligible_for_linking_to_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CwlToolDefinitionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of tools eligible for linking to the bundle.

:param bundle_id: The ID of the bundle to get the eligible tools for (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_tools_eligible_for_linking_to_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to get the eligible tools for')]) ‑> ApiResponse[CwlToolDefinitionList]

Expand source code

@validate_call
def get_tools_eligible_for_linking_to_bundle_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get the eligible tools for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[CwlToolDefinitionList]:
    """Retrieve a list of tools eligible for linking to the bundle.


    :param bundle_id: The ID of the bundle to get the eligible tools for (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_tools_eligible_for_linking_to_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CwlToolDefinitionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of tools eligible for linking to the bundle.

:param bundle_id: The ID of the bundle to get the eligible tools for (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_tools_eligible_for_linking_to_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to get the eligible tools for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_tools_eligible_for_linking_to_bundle_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to get the eligible tools for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of tools eligible for linking to the bundle.


    :param bundle_id: The ID of the bundle to get the eligible tools for (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_tools_eligible_for_linking_to_bundle_serialize(
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CwlToolDefinitionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of tools eligible for linking to the bundle.

:param bundle_id: The ID of the bundle to get the eligible tools for (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_tool_to_bundle(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to link the tool to')],
tool_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the tool to link')]) ‑> None

Expand source code

@validate_call
def link_tool_to_bundle(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to link the tool to")],
    tool_id: Annotated[StrictStr, Field(description="The ID of the tool to link")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Link a tool to a bundle


    :param bundle_id: The ID of the bundle to link the tool to (required)
    :type bundle_id: str
    :param tool_id: The ID of the tool to link (required)
    :type tool_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_tool_to_bundle_serialize(
        bundle_id=bundle_id,
        tool_id=tool_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Link a tool to a bundle

:param bundle_id: The ID of the bundle to link the tool to (required) :type bundle_id: str :param tool_id: The ID of the tool to link (required) :type tool_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_tool_to_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to link the tool to')],
tool_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the tool to link')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def link_tool_to_bundle_with_http_info(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to link the tool to")],
    tool_id: Annotated[StrictStr, Field(description="The ID of the tool to link")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Link a tool to a bundle


    :param bundle_id: The ID of the bundle to link the tool to (required)
    :type bundle_id: str
    :param tool_id: The ID of the tool to link (required)
    :type tool_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_tool_to_bundle_serialize(
        bundle_id=bundle_id,
        tool_id=tool_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Link a tool to a bundle

:param bundle_id: The ID of the bundle to link the tool to (required) :type bundle_id: str :param tool_id: The ID of the tool to link (required) :type tool_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_tool_to_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the bundle to link the tool to')],
tool_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the tool to link')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def link_tool_to_bundle_without_preload_content(
    self,
    bundle_id: Annotated[StrictStr, Field(description="The ID of the bundle to link the tool to")],
    tool_id: Annotated[StrictStr, Field(description="The ID of the tool to link")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Link a tool to a bundle


    :param bundle_id: The ID of the bundle to link the tool to (required)
    :type bundle_id: str
    :param tool_id: The ID of the tool to link (required)
    :type tool_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_tool_to_bundle_serialize(
        bundle_id=bundle_id,
        tool_id=tool_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Link a tool to a bundle

:param bundle_id: The ID of the bundle to link the tool to (required) :type bundle_id: str :param tool_id: The ID of the tool to link (required) :type tool_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_tool_from_bundle(self,
bundle_id: Annotated[str, Strict(strict=True)],
tool_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def unlink_tool_from_bundle(
    self,
    bundle_id: StrictStr,
    tool_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Unlink a tool from this bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param tool_id: (required)
    :type tool_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_tool_from_bundle_serialize(
        bundle_id=bundle_id,
        tool_id=tool_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Unlink a tool from this bundle.

:param bundle_id: (required) :type bundle_id: str :param tool_id: (required) :type tool_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_tool_from_bundle_with_http_info(self,
bundle_id: Annotated[str, Strict(strict=True)],
tool_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unlink_tool_from_bundle_with_http_info(
    self,
    bundle_id: StrictStr,
    tool_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Unlink a tool from this bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param tool_id: (required)
    :type tool_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_tool_from_bundle_serialize(
        bundle_id=bundle_id,
        tool_id=tool_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Unlink a tool from this bundle.

:param bundle_id: (required) :type bundle_id: str :param tool_id: (required) :type tool_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_tool_from_bundle_without_preload_content(self,
bundle_id: Annotated[str, Strict(strict=True)],
tool_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unlink_tool_from_bundle_without_preload_content(
    self,
    bundle_id: StrictStr,
    tool_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Unlink a tool from this bundle.


    :param bundle_id: (required)
    :type bundle_id: str
    :param tool_id: (required)
    :type tool_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_tool_from_bundle_serialize(
        bundle_id=bundle_id,
        tool_id=tool_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Unlink a tool from this bundle.

:param bundle_id: (required) :type bundle_id: str :param tool_id: (required) :type tool_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class BundleToolsList (**data: Any)

Expand source code

class BundleToolsList(BaseModel):
    """
    BundleToolsList
    """ # noqa: E501
    items: List[BundleTool]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of BundleToolsList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of BundleToolsList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [BundleTool.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

BundleToolsList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[BundleTool]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of BundleToolsList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of BundleToolsList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CWLToolDefinition (**data: Any)

Expand source code

class CWLToolDefinition(BaseModel):
    """
    CWLToolDefinition
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="Name of the tool definition")
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = Field(default=None, description="Description of the tool definition")
    status: StrictStr = Field(description="Status of the tool definition")
    version_comment: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = Field(default=None, description="version comment of the tool definition", alias="versionComment")
    release_version: Optional[StrictInt] = Field(default=None, description="release version of the tool definition", alias="releaseVersion")
    links: Optional[Link] = None
    categories: Optional[List[Optional[StrictStr]]] = Field(default=None, description="category tags as string array")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "description", "status", "versionComment", "releaseVersion", "links", "categories"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['DRAFT', 'RELEASED', 'DEPRECATED', 'RELEASECANDIDATE', 'BUILDING', 'BUILDFAILED']):
            raise ValueError("must be one of enum values ('DRAFT', 'RELEASED', 'DEPRECATED', 'RELEASECANDIDATE', 'BUILDING', 'BUILDFAILED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CWLToolDefinition from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of links
        if self.links:
            _dict['links'] = self.links.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if version_comment (nullable) is None
        # and model_fields_set contains the field
        if self.version_comment is None and "version_comment" in self.model_fields_set:
            _dict['versionComment'] = None

        # set to None if release_version (nullable) is None
        # and model_fields_set contains the field
        if self.release_version is None and "release_version" in self.model_fields_set:
            _dict['releaseVersion'] = None

        # set to None if categories (nullable) is None
        # and model_fields_set contains the field
        if self.categories is None and "categories" in self.model_fields_set:
            _dict['categories'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CWLToolDefinition from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "description": obj.get("description"),
            "status": obj.get("status"),
            "versionComment": obj.get("versionComment"),
            "releaseVersion": obj.get("releaseVersion"),
            "links": Link.from_dict(obj["links"]) if obj.get("links") is not None else None,
            "categories": obj.get("categories")
        })
        return _obj

CWLToolDefinition

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var categories : List[str | None] | None

The type of the None singleton.

var description : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var links : Link | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var release_version : int | None

The type of the None singleton.

var status : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var version_comment : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CWLToolDefinition from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CWLToolDefinition from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of links
    if self.links:
        _dict['links'] = self.links.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if version_comment (nullable) is None
    # and model_fields_set contains the field
    if self.version_comment is None and "version_comment" in self.model_fields_set:
        _dict['versionComment'] = None

    # set to None if release_version (nullable) is None
    # and model_fields_set contains the field
    if self.release_version is None and "release_version" in self.model_fields_set:
        _dict['releaseVersion'] = None

    # set to None if categories (nullable) is None
    # and model_fields_set contains the field
    if self.categories is None and "categories" in self.model_fields_set:
        _dict['categories'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ChangeProjectOwner (**data: Any)

Expand source code

class ChangeProjectOwner(BaseModel):
    """
    ChangeProjectOwner
    """ # noqa: E501
    new_owner_id: StrictStr = Field(description="The id of the new project owner.", alias="newOwnerId")
    __properties: ClassVar[List[str]] = ["newOwnerId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ChangeProjectOwner from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ChangeProjectOwner from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "newOwnerId": obj.get("newOwnerId")
        })
        return _obj

ChangeProjectOwner

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var new_owner_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ChangeProjectOwner from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ChangeProjectOwner from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CompleteFolderUploadSession (**data: Any)

Expand source code

class CompleteFolderUploadSession(BaseModel):
    """
    CompleteFolderUploadSession
    """ # noqa: E501
    number_of_expected_uploaded_files: StrictInt = Field(description="The number of expected uploaded files within this session.", alias="numberOfExpectedUploadedFiles")
    __properties: ClassVar[List[str]] = ["numberOfExpectedUploadedFiles"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CompleteFolderUploadSession from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CompleteFolderUploadSession from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "numberOfExpectedUploadedFiles": obj.get("numberOfExpectedUploadedFiles")
        })
        return _obj

CompleteFolderUploadSession

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var number_of_expected_uploaded_files : int

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CompleteFolderUploadSession from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CompleteFolderUploadSession from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Config (**data: Any)

Expand source code

class Config(BaseModel):
    """
    Config
    """ # noqa: E501
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="name of the report")
    regex: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="regex pattern of the filename")
    format: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="Format of the file")
    __properties: ClassVar[List[str]] = ["name", "regex", "format"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Config from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if format (nullable) is None
        # and model_fields_set contains the field
        if self.format is None and "format" in self.model_fields_set:
            _dict['format'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Config from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "regex": obj.get("regex"),
            "format": obj.get("format")
        })
        return _obj

Config

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var format : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var regex : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Config from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Config from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if format (nullable) is None
    # and model_fields_set contains the field
    if self.format is None and "format" in self.model_fields_set:
        _dict['format'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Configuration (host: str | None = None,
api_key: Dict[str, str] | None = None,
api_key_prefix: Dict[str, str] | None = None,
username: str | None = None,
password: str | None = None,
access_token: str | None = None,
server_index: int | None = None,
server_variables: Dict[str, str] | None = None,
server_operation_index: Dict[int, int] | None = None,
server_operation_variables: Dict[int, Dict[str, str]] | None = None,
ignore_operation_servers: bool = False,
ssl_ca_cert: str | None = None,
retries: int | None = None,
ca_cert_data: str | bytes | None = None,
*,
debug: bool | None = None)

Expand source code

class Configuration:
    """This class contains various settings of the API client.

    :param host: Base url.
    :param ignore_operation_servers
      Boolean to ignore operation servers for the API client.
      Config will use `host` as the base url regardless of the operation servers.
    :param api_key: Dict to store API key(s).
      Each entry in the dict specifies an API key.
      The dict key is the name of the security scheme in the OAS specification.
      The dict value is the API key secret.
    :param api_key_prefix: Dict to store API prefix (e.g. Bearer).
      The dict key is the name of the security scheme in the OAS specification.
      The dict value is an API key prefix when generating the auth data.
    :param username: Username for HTTP basic authentication.
    :param password: Password for HTTP basic authentication.
    :param access_token: Access token.
    :param server_index: Index to servers configuration.
    :param server_variables: Mapping with string values to replace variables in
      templated server configuration. The validation of enums is performed for
      variables with defined enum values before.
    :param server_operation_index: Mapping from operation ID to an index to server
      configuration.
    :param server_operation_variables: Mapping from operation ID to a mapping with
      string values to replace variables in templated server configuration.
      The validation of enums is performed for variables with defined enum
      values before.
    :param ssl_ca_cert: str - the path to a file of concatenated CA certificates
      in PEM format.
    :param retries: Number of retries for API requests.
    :param ca_cert_data: verify the peer using concatenated CA certificate data
      in PEM (str) or DER (bytes) format.

    :Example:

    API Key Authentication Example.
    Given the following security scheme in the OpenAPI specification:
      components:
        securitySchemes:
          cookieAuth:         # name for the security scheme
            type: apiKey
            in: cookie
            name: JSESSIONID  # cookie name

    You can programmatically set the cookie:

conf = libica.openapi.v3.Configuration(
    api_key={'cookieAuth': 'abc123'}
    api_key_prefix={'cookieAuth': 'JSESSIONID'}
)

    The following cookie will be added to the HTTP request:
       Cookie: JSESSIONID abc123

    HTTP Basic Authentication Example.
    Given the following security scheme in the OpenAPI specification:
      components:
        securitySchemes:
          http_basic_auth:
            type: http
            scheme: basic

    Configure API client with HTTP basic authentication:

conf = libica.openapi.v3.Configuration(
    username='the-user',
    password='the-password',    # pragma: allowlist secret
)

    """

    _default: ClassVar[Optional[Self]] = None

    def __init__(
        self,
        host: Optional[str]=None,
        api_key: Optional[Dict[str, str]]=None,
        api_key_prefix: Optional[Dict[str, str]]=None,
        username: Optional[str]=None,
        password: Optional[str]=None,
        access_token: Optional[str]=None,
        server_index: Optional[int]=None,
        server_variables: Optional[ServerVariablesT]=None,
        server_operation_index: Optional[Dict[int, int]]=None,
        server_operation_variables: Optional[Dict[int, ServerVariablesT]]=None,
        ignore_operation_servers: bool=False,
        ssl_ca_cert: Optional[str]=None,
        retries: Optional[int] = None,
        ca_cert_data: Optional[Union[str, bytes]] = None,
        *,
        debug: Optional[bool] = None,
    ) -> None:
        """Constructor
        """
        self._base_path = "/ica/rest" if host is None else host
        """Default Base url
        """
        self.server_index = 0 if server_index is None and host is None else server_index
        self.server_operation_index = server_operation_index or {}
        """Default server index
        """
        self.server_variables = server_variables or {}
        self.server_operation_variables = server_operation_variables or {}
        """Default server variables
        """
        self.ignore_operation_servers = ignore_operation_servers
        """Ignore operation servers
        """
        self.temp_folder_path = None
        """Temp file folder for downloading files
        """
        # Authentication Settings
        self.api_key = {}
        if api_key:
            self.api_key = api_key
        """dict to store API key(s)
        """
        self.api_key_prefix = {}
        if api_key_prefix:
            self.api_key_prefix = api_key_prefix
        """dict to store API prefix (e.g. Bearer)
        """
        self.refresh_api_key_hook = None
        """function hook to refresh API key if expired
        """
        self.username = username
        """Username for HTTP basic authentication
        """
        self.password = password
        """Password for HTTP basic authentication
        """
        self.access_token = access_token
        """Access token
        """
        self.logger = {}
        """Logging Settings
        """
        self.logger["package_logger"] = logging.getLogger("libica.openapi.v3")
        self.logger["urllib3_logger"] = logging.getLogger("urllib3")
        self.logger_format = '%(asctime)s %(levelname)s %(message)s'
        """Log format
        """
        self.logger_stream_handler = None
        """Log stream handler
        """
        self.logger_file_handler: Optional[FileHandler] = None
        """Log file handler
        """
        self.logger_file = None
        """Debug file location
        """
        if debug is not None:
            self.debug = debug
        else:
            self.__debug = False
        """Debug switch
        """

        self.verify_ssl = True
        """SSL/TLS verification
           Set this to false to skip verifying SSL certificate when calling API
           from https server.
        """
        self.ssl_ca_cert = ssl_ca_cert
        """Set this to customize the certificate file to verify the peer.
        """
        self.ca_cert_data = ca_cert_data
        """Set this to verify the peer using PEM (str) or DER (bytes)
           certificate data.
        """
        self.cert_file = None
        """client certificate file
        """
        self.key_file = None
        """client key file
        """
        self.assert_hostname = None
        """Set this to True/False to enable/disable SSL hostname verification.
        """
        self.tls_server_name = None
        """SSL/TLS Server Name Indication (SNI)
           Set this to the SNI value expected by the server.
        """

        self.connection_pool_maxsize = multiprocessing.cpu_count() * 5
        """urllib3 connection pool's maximum number of connections saved
           per pool. urllib3 uses 1 connection as default value, but this is
           not the best value when you are making a lot of possibly parallel
           requests to the same host, which is often the case here.
           cpu_count * 5 is used as default value to increase performance.
        """

        self.proxy: Optional[str] = None
        """Proxy URL
        """
        self.proxy_headers = None
        """Proxy headers
        """
        self.safe_chars_for_path_param = ''
        """Safe chars for path_param
        """
        self.retries = retries
        """Adding retries to override urllib3 default value 3
        """
        # Enable client side validation
        self.client_side_validation = True

        self.socket_options = None
        """Options to pass down to the underlying urllib3 socket
        """

        self.datetime_format = "%Y-%m-%dT%H:%M:%S.%f%z"
        """datetime format
        """

        self.date_format = "%Y-%m-%d"
        """date format
        """

    def __deepcopy__(self, memo:  Dict[int, Any]) -> Self:
        cls = self.__class__
        result = cls.__new__(cls)
        memo[id(self)] = result
        for k, v in self.__dict__.items():
            if k not in ('logger', 'logger_file_handler'):
                setattr(result, k, copy.deepcopy(v, memo))
        # shallow copy of loggers
        result.logger = copy.copy(self.logger)
        # use setters to configure loggers
        result.logger_file = self.logger_file
        result.debug = self.debug
        return result

    def __setattr__(self, name: str, value: Any) -> None:
        object.__setattr__(self, name, value)

    @classmethod
    def set_default(cls, default: Optional[Self]) -> None:
        """Set default instance of configuration.

        It stores default configuration, which can be
        returned by get_default_copy method.

        :param default: object of Configuration
        """
        cls._default = default

    @classmethod
    def get_default_copy(cls) -> Self:
        """Deprecated. Please use `get_default` instead.

        Deprecated. Please use `get_default` instead.

        :return: The configuration object.
        """
        return cls.get_default()

    @classmethod
    def get_default(cls) -> Self:
        """Return the default configuration.

        This method returns newly created, based on default constructor,
        object of Configuration class or returns a copy of default
        configuration.

        :return: The configuration object.
        """
        if cls._default is None:
            cls._default = cls()
        return cls._default

    @property
    def logger_file(self) -> Optional[str]:
        """The logger file.

        If the logger_file is None, then add stream handler and remove file
        handler. Otherwise, add file handler and remove stream handler.

        :param value: The logger_file path.
        :type: str
        """
        return self.__logger_file

    @logger_file.setter
    def logger_file(self, value: Optional[str]) -> None:
        """The logger file.

        If the logger_file is None, then add stream handler and remove file
        handler. Otherwise, add file handler and remove stream handler.

        :param value: The logger_file path.
        :type: str
        """
        self.__logger_file = value
        if self.__logger_file:
            # If set logging file,
            # then add file handler and remove stream handler.
            self.logger_file_handler = logging.FileHandler(self.__logger_file)
            self.logger_file_handler.setFormatter(self.logger_formatter)
            for _, logger in self.logger.items():
                logger.addHandler(self.logger_file_handler)

    @property
    def debug(self) -> bool:
        """Debug status

        :param value: The debug status, True or False.
        :type: bool
        """
        return self.__debug

    @debug.setter
    def debug(self, value: bool) -> None:
        """Debug status

        :param value: The debug status, True or False.
        :type: bool
        """
        self.__debug = value
        if self.__debug:
            # if debug status is True, turn on debug logging
            for _, logger in self.logger.items():
                logger.setLevel(logging.DEBUG)
            # turn on httplib debug
            httplib.HTTPConnection.debuglevel = 1
        else:
            # if debug status is False, turn off debug logging,
            # setting log level to default `logging.WARNING`
            for _, logger in self.logger.items():
                logger.setLevel(logging.WARNING)
            # turn off httplib debug
            httplib.HTTPConnection.debuglevel = 0

    @property
    def logger_format(self) -> str:
        """The logger format.

        The logger_formatter will be updated when sets logger_format.

        :param value: The format string.
        :type: str
        """
        return self.__logger_format

    @logger_format.setter
    def logger_format(self, value: str) -> None:
        """The logger format.

        The logger_formatter will be updated when sets logger_format.

        :param value: The format string.
        :type: str
        """
        self.__logger_format = value
        self.logger_formatter = logging.Formatter(self.__logger_format)

    def get_api_key_with_prefix(self, identifier: str, alias: Optional[str]=None) -> Optional[str]:
        """Gets API key (with prefix if set).

        :param identifier: The identifier of apiKey.
        :param alias: The alternative identifier of apiKey.
        :return: The token for api key authentication.
        """
        if self.refresh_api_key_hook is not None:
            self.refresh_api_key_hook(self)
        key = self.api_key.get(identifier, self.api_key.get(alias) if alias is not None else None)
        if key:
            prefix = self.api_key_prefix.get(identifier)
            if prefix:
                return "%s %s" % (prefix, key)
            else:
                return key

        return None

    def get_basic_auth_token(self) -> Optional[str]:
        """Gets HTTP basic authentication header (string).

        :return: The token for basic HTTP authentication.
        """
        username = ""
        if self.username is not None:
            username = self.username
        password = ""
        if self.password is not None:
            password = self.password
        return urllib3.util.make_headers(
            basic_auth=username + ':' + password
        ).get('authorization')

    def auth_settings(self)-> AuthSettings:
        """Gets Auth Settings dict for api client.

        :return: The Auth Settings information dict.
        """
        auth: AuthSettings = {}
        if self.access_token is not None:
            auth['JwtAuth'] = {
                'type': 'bearer',
                'in': 'header',
                'format': 'JWT',
                'key': 'Authorization',
                'value': 'Bearer ' + self.access_token
            }
        if self.access_token is not None:
            auth['PsTokenAuth'] = {
                'type': 'bearer',
                'in': 'header',
                'format': 'psToken',
                'key': 'Authorization',
                'value': 'Bearer ' + self.access_token
            }
        if 'ApiKeyAuth' in self.api_key:
            auth['ApiKeyAuth'] = {
                'type': 'api_key',
                'in': 'header',
                'key': 'X-API-Key',
                'value': self.get_api_key_with_prefix(
                    'ApiKeyAuth',
                ),
            }
        if self.username is not None and self.password is not None:
            auth['BasicAuth'] = {
                'type': 'basic',
                'in': 'header',
                'key': 'Authorization',
                'value': self.get_basic_auth_token()
            }
        return auth

    def to_debug_report(self) -> str:
        """Gets the essential information for debugging.

        :return: The report for debugging.
        """
        return "Python SDK Debug Report:\n"\
               "OS: {env}\n"\
               "Python Version: {pyversion}\n"\
               "Version of the API: 3\n"\
               "SDK Package Version: 1.0.0".\
               format(env=sys.platform, pyversion=sys.version)

    def get_host_settings(self) -> List[HostSetting]:
        """Gets an array of host settings

        :return: An array of host settings
        """
        return [
            {
                'url': "/ica/rest",
                'description': "No description provided",
            }
        ]

    def get_host_from_settings(
        self,
        index: Optional[int],
        variables: Optional[ServerVariablesT]=None,
        servers: Optional[List[HostSetting]]=None,
    ) -> str:
        """Gets host URL based on the index and variables
        :param index: array index of the host settings
        :param variables: hash of variable and the corresponding value
        :param servers: an array of host settings or None
        :return: URL based on host settings
        """
        if index is None:
            return self._base_path

        variables = {} if variables is None else variables
        servers = self.get_host_settings() if servers is None else servers

        try:
            server = servers[index]
        except IndexError:
            raise ValueError(
                "Invalid index {0} when selecting the host settings. "
                "Must be less than {1}".format(index, len(servers)))

        url = server['url']

        # go through variables and replace placeholders
        for variable_name, variable in server.get('variables', {}).items():
            used_value = variables.get(
                variable_name, variable['default_value'])

            if 'enum_values' in variable \
                    and used_value not in variable['enum_values']:
                raise ValueError(
                    "The variable `{0}` in the host URL has invalid value "
                    "{1}. Must be {2}.".format(
                        variable_name, variables[variable_name],
                        variable['enum_values']))

            url = url.replace("{" + variable_name + "}", used_value)

        return url

    @property
    def host(self) -> str:
        """Return generated host."""
        return self.get_host_from_settings(self.server_index, variables=self.server_variables)

    @host.setter
    def host(self, value: str) -> None:
        """Fix base path."""
        self._base_path = value
        self.server_index = None

This class contains various settings of the API client.

:param host: Base url.
:param ignore_operation_servers
  Boolean to ignore operation servers for the API client.
  Config will use <code>host</code> as the base url regardless of the operation servers.
:param api_key: Dict to store API key(s).
  Each entry in the dict specifies an API key.
  The dict key is the name of the security scheme in the OAS specification.
  The dict value is the API key secret.
:param api_key_prefix: Dict to store API prefix (e.g. Bearer).
  The dict key is the name of the security scheme in the OAS specification.
  The dict value is an API key prefix when generating the auth data.
:param username: Username for HTTP basic authentication.
:param password: Password for HTTP basic authentication.
:param access_token: Access token.
:param server_index: Index to servers configuration.
:param server_variables: Mapping with string values to replace variables in
  templated server configuration. The validation of enums is performed for
  variables with defined enum values before.
:param server_operation_index: Mapping from operation ID to an index to server
  configuration.
:param server_operation_variables: Mapping from operation ID to a mapping with
  string values to replace variables in templated server configuration.
  The validation of enums is performed for variables with defined enum
  values before.
:param ssl_ca_cert: str - the path to a file of concatenated CA certificates
  in PEM format.
:param retries: Number of retries for API requests.
:param ca_cert_data: verify the peer using concatenated CA certificate data
  in PEM (str) or DER (bytes) format.

:Example:

API Key Authentication Example.
Given the following security scheme in the OpenAPI specification:
  components:
    securitySchemes:
      cookieAuth:         # name for the security scheme
        type: apiKey
        in: cookie
        name: JSESSIONID  # cookie name

You can programmatically set the cookie:

conf = libica.openapi.v3.Configuration( api_key={'cookieAuth': 'abc123'} api_key_prefix={'cookieAuth': 'JSESSIONID'} )

The following cookie will be added to the HTTP request:
   Cookie: JSESSIONID abc123

HTTP Basic Authentication Example.
Given the following security scheme in the OpenAPI specification:
  components:
    securitySchemes:
      http_basic_auth:
        type: http
        scheme: basic

Configure API client with HTTP basic authentication:

conf = libica.openapi.v3.Configuration( username='the-user', password='the-password', # pragma: allowlist secret )

Constructor

Static methods

def get_default() ‑> Self

Return the default configuration.

This method returns newly created, based on default constructor, object of Configuration class or returns a copy of default configuration.

:return: The configuration object.

def get_default_copy() ‑> Self

Deprecated. Please use get_default instead.

Deprecated. Please use get_default instead.

:return: The configuration object.

def set_default(default: Self | None) ‑> None

Set default instance of configuration.

It stores default configuration, which can be returned by get_default_copy method.

:param default: object of Configuration

Instance variables

var access_token

Access token

var assert_hostname

Set this to True/False to enable/disable SSL hostname verification.

var ca_cert_data

Set this to verify the peer using PEM (str) or DER (bytes) certificate data.

var cert_file

client certificate file

var connection_pool_maxsize

urllib3 connection pool's maximum number of connections saved per pool. urllib3 uses 1 connection as default value, but this is not the best value when you are making a lot of possibly parallel requests to the same host, which is often the case here. cpu_count * 5 is used as default value to increase performance.

var date_format

date format

var datetime_format

datetime format

prop debug : bool

Expand source code

@property
def debug(self) -> bool:
    """Debug status

    :param value: The debug status, True or False.
    :type: bool
    """
    return self.__debug

Debug status

:param value: The debug status, True or False. :type: bool

prop host : str

Expand source code

@property
def host(self) -> str:
    """Return generated host."""
    return self.get_host_from_settings(self.server_index, variables=self.server_variables)

Return generated host.

var ignore_operation_servers

Ignore operation servers

var key_file

client key file

var logger

Logging Settings

var logger_file : str | None

Expand source code

@property
def logger_file(self) -> Optional[str]:
    """The logger file.

    If the logger_file is None, then add stream handler and remove file
    handler. Otherwise, add file handler and remove stream handler.

    :param value: The logger_file path.
    :type: str
    """
    return self.__logger_file

Debug file location

var logger_file_handler

Log file handler

var logger_format : str

Expand source code

@property
def logger_format(self) -> str:
    """The logger format.

    The logger_formatter will be updated when sets logger_format.

    :param value: The format string.
    :type: str
    """
    return self.__logger_format

Log format

var logger_stream_handler

Log stream handler

var password

Password for HTTP basic authentication

var proxy

Proxy URL

var proxy_headers

Proxy headers

var refresh_api_key_hook

function hook to refresh API key if expired

var retries

Adding retries to override urllib3 default value 3

var safe_chars_for_path_param

Safe chars for path_param

var server_operation_index

Default server index

var server_operation_variables

Default server variables

var socket_options

Options to pass down to the underlying urllib3 socket

var ssl_ca_cert

Set this to customize the certificate file to verify the peer.

var temp_folder_path

Temp file folder for downloading files

var tls_server_name

SSL/TLS Server Name Indication (SNI) Set this to the SNI value expected by the server.

var username

Username for HTTP basic authentication

var verify_ssl

SSL/TLS verification Set this to false to skip verifying SSL certificate when calling API from https server.

Methods

def auth_settings(self) ‑> AuthSettings

Expand source code

def auth_settings(self)-> AuthSettings:
    """Gets Auth Settings dict for api client.

    :return: The Auth Settings information dict.
    """
    auth: AuthSettings = {}
    if self.access_token is not None:
        auth['JwtAuth'] = {
            'type': 'bearer',
            'in': 'header',
            'format': 'JWT',
            'key': 'Authorization',
            'value': 'Bearer ' + self.access_token
        }
    if self.access_token is not None:
        auth['PsTokenAuth'] = {
            'type': 'bearer',
            'in': 'header',
            'format': 'psToken',
            'key': 'Authorization',
            'value': 'Bearer ' + self.access_token
        }
    if 'ApiKeyAuth' in self.api_key:
        auth['ApiKeyAuth'] = {
            'type': 'api_key',
            'in': 'header',
            'key': 'X-API-Key',
            'value': self.get_api_key_with_prefix(
                'ApiKeyAuth',
            ),
        }
    if self.username is not None and self.password is not None:
        auth['BasicAuth'] = {
            'type': 'basic',
            'in': 'header',
            'key': 'Authorization',
            'value': self.get_basic_auth_token()
        }
    return auth

Gets Auth Settings dict for api client.

:return: The Auth Settings information dict.

def get_api_key_with_prefix(self, identifier: str, alias: str | None = None) ‑> str | None

Expand source code

def get_api_key_with_prefix(self, identifier: str, alias: Optional[str]=None) -> Optional[str]:
    """Gets API key (with prefix if set).

    :param identifier: The identifier of apiKey.
    :param alias: The alternative identifier of apiKey.
    :return: The token for api key authentication.
    """
    if self.refresh_api_key_hook is not None:
        self.refresh_api_key_hook(self)
    key = self.api_key.get(identifier, self.api_key.get(alias) if alias is not None else None)
    if key:
        prefix = self.api_key_prefix.get(identifier)
        if prefix:
            return "%s %s" % (prefix, key)
        else:
            return key

    return None

Gets API key (with prefix if set).

:param identifier: The identifier of apiKey. :param alias: The alternative identifier of apiKey. :return: The token for api key authentication.

def get_basic_auth_token(self) ‑> str | None

Expand source code

def get_basic_auth_token(self) -> Optional[str]:
    """Gets HTTP basic authentication header (string).

    :return: The token for basic HTTP authentication.
    """
    username = ""
    if self.username is not None:
        username = self.username
    password = ""
    if self.password is not None:
        password = self.password
    return urllib3.util.make_headers(
        basic_auth=username + ':' + password
    ).get('authorization')

Gets HTTP basic authentication header (string).

:return: The token for basic HTTP authentication.

def get_host_from_settings(self,
index: int | None,
variables: Dict[str, str] | None = None,
servers: List[HostSetting] | None = None) ‑> str

Expand source code

def get_host_from_settings(
    self,
    index: Optional[int],
    variables: Optional[ServerVariablesT]=None,
    servers: Optional[List[HostSetting]]=None,
) -> str:
    """Gets host URL based on the index and variables
    :param index: array index of the host settings
    :param variables: hash of variable and the corresponding value
    :param servers: an array of host settings or None
    :return: URL based on host settings
    """
    if index is None:
        return self._base_path

    variables = {} if variables is None else variables
    servers = self.get_host_settings() if servers is None else servers

    try:
        server = servers[index]
    except IndexError:
        raise ValueError(
            "Invalid index {0} when selecting the host settings. "
            "Must be less than {1}".format(index, len(servers)))

    url = server['url']

    # go through variables and replace placeholders
    for variable_name, variable in server.get('variables', {}).items():
        used_value = variables.get(
            variable_name, variable['default_value'])

        if 'enum_values' in variable \
                and used_value not in variable['enum_values']:
            raise ValueError(
                "The variable `{0}` in the host URL has invalid value "
                "{1}. Must be {2}.".format(
                    variable_name, variables[variable_name],
                    variable['enum_values']))

        url = url.replace("{" + variable_name + "}", used_value)

    return url

Gets host URL based on the index and variables :param index: array index of the host settings :param variables: hash of variable and the corresponding value :param servers: an array of host settings or None :return: URL based on host settings

def get_host_settings(self) ‑> List[HostSetting]

Expand source code

def get_host_settings(self) -> List[HostSetting]:
    """Gets an array of host settings

    :return: An array of host settings
    """
    return [
        {
            'url': "/ica/rest",
            'description': "No description provided",
        }
    ]

Gets an array of host settings

:return: An array of host settings

def to_debug_report(self) ‑> str

Expand source code

def to_debug_report(self) -> str:
    """Gets the essential information for debugging.

    :return: The report for debugging.
    """
    return "Python SDK Debug Report:\n"\
           "OS: {env}\n"\
           "Python Version: {pyversion}\n"\
           "Version of the API: 3\n"\
           "SDK Package Version: 1.0.0".\
           format(env=sys.platform, pyversion=sys.version)

Gets the essential information for debugging.

:return: The report for debugging.

class Connector (**data: Any)

Expand source code

class Connector(BaseModel):
    """
    Connector
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    active: StrictBool
    connected: StrictBool = Field(description="Indicates if the connector is connected or not. This is cached so even when the connector is no longer connected, for a short time this still may return true.")
    technical_code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="Technical code to be used for processing.", alias="technicalCode")
    initialization_key: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="The key provided via other channels to initialize the installation.", alias="initializationKey")
    description: Optional[StrictStr] = Field(default=None, description="The general description of the connector instance including its purpose.")
    mode: StrictStr = Field(description="The mode the connector runs in.")
    max_bandwidth: Optional[Union[Annotated[float, Field(strict=True, ge=0.01)], Annotated[int, Field(strict=True, ge=1)]]] = Field(default=None, description="The maximum bandwidth defined in MB per second.", alias="maxBandwidth")
    max_concurrent_transfers: Optional[Annotated[int, Field(strict=True, ge=1)]] = Field(default=None, description="The maximum amount of concurrent transfers that this connector can execute.", alias="maxConcurrentTransfers")
    os: StrictStr = Field(description="The target OS of the original connector installer.")
    installation_status: StrictStr = Field(alias="installationStatus")
    new_connector_version_available: StrictBool = Field(alias="newConnectorVersionAvailable")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "code", "active", "connected", "technicalCode", "initializationKey", "description", "mode", "maxBandwidth", "maxConcurrentTransfers", "os", "installationStatus", "newConnectorVersionAvailable"]

    @field_validator('mode')
    def mode_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['DOWNLOAD', 'UPLOAD', 'BOTH', 'NONE']):
            raise ValueError("must be one of enum values ('DOWNLOAD', 'UPLOAD', 'BOTH', 'NONE')")
        return value

    @field_validator('os')
    def os_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['WINDOWS', 'LINUX', 'OSX']):
            raise ValueError("must be one of enum values ('WINDOWS', 'LINUX', 'OSX')")
        return value

    @field_validator('installation_status')
    def installation_status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['PENDING_INSTALLATION', 'INSTALLED', 'ERROR', 'UNKNOWN', 'CANCELLED']):
            raise ValueError("must be one of enum values ('PENDING_INSTALLATION', 'INSTALLED', 'ERROR', 'UNKNOWN', 'CANCELLED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Connector from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if initialization_key (nullable) is None
        # and model_fields_set contains the field
        if self.initialization_key is None and "initialization_key" in self.model_fields_set:
            _dict['initializationKey'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if max_bandwidth (nullable) is None
        # and model_fields_set contains the field
        if self.max_bandwidth is None and "max_bandwidth" in self.model_fields_set:
            _dict['maxBandwidth'] = None

        # set to None if max_concurrent_transfers (nullable) is None
        # and model_fields_set contains the field
        if self.max_concurrent_transfers is None and "max_concurrent_transfers" in self.model_fields_set:
            _dict['maxConcurrentTransfers'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Connector from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "code": obj.get("code"),
            "active": obj.get("active"),
            "connected": obj.get("connected"),
            "technicalCode": obj.get("technicalCode"),
            "initializationKey": obj.get("initializationKey"),
            "description": obj.get("description"),
            "mode": obj.get("mode"),
            "maxBandwidth": obj.get("maxBandwidth"),
            "maxConcurrentTransfers": obj.get("maxConcurrentTransfers"),
            "os": obj.get("os"),
            "installationStatus": obj.get("installationStatus"),
            "newConnectorVersionAvailable": obj.get("newConnectorVersionAvailable")
        })
        return _obj

Connector

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var active : bool

The type of the None singleton.

var code : str

The type of the None singleton.

var connected : bool

The type of the None singleton.

var description : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var initialization_key : str | None

The type of the None singleton.

var installation_status : str

The type of the None singleton.

var max_bandwidth : float | int | None

The type of the None singleton.

var max_concurrent_transfers : int | None

The type of the None singleton.

var mode : str

The type of the None singleton.

var model_config

The type of the None singleton.

var new_connector_version_available : bool

The type of the None singleton.

var os : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var technical_code : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Connector from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Connector from a JSON string

def installation_status_validate_enum(value)

Validates the enum

def mode_validate_enum(value)

Validates the enum

def os_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if initialization_key (nullable) is None
    # and model_fields_set contains the field
    if self.initialization_key is None and "initialization_key" in self.model_fields_set:
        _dict['initializationKey'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if max_bandwidth (nullable) is None
    # and model_fields_set contains the field
    if self.max_bandwidth is None and "max_bandwidth" in self.model_fields_set:
        _dict['maxBandwidth'] = None

    # set to None if max_concurrent_transfers (nullable) is None
    # and model_fields_set contains the field
    if self.max_concurrent_transfers is None and "max_concurrent_transfers" in self.model_fields_set:
        _dict['maxConcurrentTransfers'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ConnectorApi (api_client=None)

Expand source code

class ConnectorApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def cancel_connector(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Cancel a connector.

        Endpoint for cancelling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._cancel_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def cancel_connector_with_http_info(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Cancel a connector.

        Endpoint for cancelling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._cancel_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def cancel_connector_without_preload_content(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Cancel a connector.

        Endpoint for cancelling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._cancel_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _cancel_connector_serialize(
        self,
        connector_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/connectors/{connectorId}:cancel',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_connector(
        self,
        create_connector: Annotated[CreateConnector, Field(description="The connector to create.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Connector:
        """Create a connector.


        :param create_connector: The connector to create. (required)
        :type create_connector: CreateConnector
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_connector_serialize(
            create_connector=create_connector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "Connector",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_connector_with_http_info(
        self,
        create_connector: Annotated[CreateConnector, Field(description="The connector to create.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Connector]:
        """Create a connector.


        :param create_connector: The connector to create. (required)
        :type create_connector: CreateConnector
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_connector_serialize(
            create_connector=create_connector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "Connector",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_connector_without_preload_content(
        self,
        create_connector: Annotated[CreateConnector, Field(description="The connector to create.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a connector.


        :param create_connector: The connector to create. (required)
        :type create_connector: CreateConnector
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_connector_serialize(
            create_connector=create_connector,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "Connector",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_connector_serialize(
        self,
        create_connector,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_connector is not None:
            _body_params = create_connector


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/connectors',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_download_rule(
        self,
        connector_id: StrictStr,
        create_download_rule: Annotated[CreateDownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DownloadRule:
        """Create a download rule.


        :param connector_id: (required)
        :type connector_id: str
        :param create_download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type create_download_rule: CreateDownloadRule
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_rule_serialize(
            connector_id=connector_id,
            create_download_rule=create_download_rule,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "DownloadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_download_rule_with_http_info(
        self,
        connector_id: StrictStr,
        create_download_rule: Annotated[CreateDownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DownloadRule]:
        """Create a download rule.


        :param connector_id: (required)
        :type connector_id: str
        :param create_download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type create_download_rule: CreateDownloadRule
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_rule_serialize(
            connector_id=connector_id,
            create_download_rule=create_download_rule,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "DownloadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_download_rule_without_preload_content(
        self,
        connector_id: StrictStr,
        create_download_rule: Annotated[CreateDownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a download rule.


        :param connector_id: (required)
        :type connector_id: str
        :param create_download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type create_download_rule: CreateDownloadRule
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_rule_serialize(
            connector_id=connector_id,
            create_download_rule=create_download_rule,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "DownloadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_download_rule_serialize(
        self,
        connector_id,
        create_download_rule,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_download_rule is not None:
            _body_params = create_download_rule


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/connectors/{connectorId}/downloadRules',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_upload_rule(
        self,
        connector_id: StrictStr,
        create_upload_rule: Annotated[CreateUploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> UploadRule:
        """Create an upload rule.


        :param connector_id: (required)
        :type connector_id: str
        :param create_upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type create_upload_rule: CreateUploadRule
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_upload_rule_serialize(
            connector_id=connector_id,
            create_upload_rule=create_upload_rule,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "UploadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_upload_rule_with_http_info(
        self,
        connector_id: StrictStr,
        create_upload_rule: Annotated[CreateUploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[UploadRule]:
        """Create an upload rule.


        :param connector_id: (required)
        :type connector_id: str
        :param create_upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type create_upload_rule: CreateUploadRule
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_upload_rule_serialize(
            connector_id=connector_id,
            create_upload_rule=create_upload_rule,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "UploadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_upload_rule_without_preload_content(
        self,
        connector_id: StrictStr,
        create_upload_rule: Annotated[CreateUploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create an upload rule.


        :param connector_id: (required)
        :type connector_id: str
        :param create_upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type create_upload_rule: CreateUploadRule
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_upload_rule_serialize(
            connector_id=connector_id,
            create_upload_rule=create_upload_rule,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "UploadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_upload_rule_serialize(
        self,
        connector_id,
        create_upload_rule,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_upload_rule is not None:
            _body_params = create_upload_rule


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/connectors/{connectorId}/uploadRules',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_download_rule(
        self,
        connector_id: StrictStr,
        download_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a download rule.


        :param connector_id: (required)
        :type connector_id: str
        :param download_rule_id: (required)
        :type download_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_download_rule_serialize(
            connector_id=connector_id,
            download_rule_id=download_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_download_rule_with_http_info(
        self,
        connector_id: StrictStr,
        download_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a download rule.


        :param connector_id: (required)
        :type connector_id: str
        :param download_rule_id: (required)
        :type download_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_download_rule_serialize(
            connector_id=connector_id,
            download_rule_id=download_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_download_rule_without_preload_content(
        self,
        connector_id: StrictStr,
        download_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a download rule.


        :param connector_id: (required)
        :type connector_id: str
        :param download_rule_id: (required)
        :type download_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_download_rule_serialize(
            connector_id=connector_id,
            download_rule_id=download_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_download_rule_serialize(
        self,
        connector_id,
        download_rule_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        if download_rule_id is not None:
            _path_params['downloadRuleId'] = download_rule_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/connectors/{connectorId}/downloadRules/{downloadRuleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_upload_rule(
        self,
        connector_id: StrictStr,
        upload_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete an upload rule.


        :param connector_id: (required)
        :type connector_id: str
        :param upload_rule_id: (required)
        :type upload_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_upload_rule_serialize(
            connector_id=connector_id,
            upload_rule_id=upload_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_upload_rule_with_http_info(
        self,
        connector_id: StrictStr,
        upload_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete an upload rule.


        :param connector_id: (required)
        :type connector_id: str
        :param upload_rule_id: (required)
        :type upload_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_upload_rule_serialize(
            connector_id=connector_id,
            upload_rule_id=upload_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_upload_rule_without_preload_content(
        self,
        connector_id: StrictStr,
        upload_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete an upload rule.


        :param connector_id: (required)
        :type connector_id: str
        :param upload_rule_id: (required)
        :type upload_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_upload_rule_serialize(
            connector_id=connector_id,
            upload_rule_id=upload_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_upload_rule_serialize(
        self,
        connector_id,
        upload_rule_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        if upload_rule_id is not None:
            _path_params['uploadRuleId'] = upload_rule_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/connectors/{connectorId}/uploadRules/{uploadRuleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def disable_connector(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Disable a connector.

        Endpoint for disabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._disable_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def disable_connector_with_http_info(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Disable a connector.

        Endpoint for disabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._disable_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def disable_connector_without_preload_content(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Disable a connector.

        Endpoint for disabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._disable_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _disable_connector_serialize(
        self,
        connector_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/connectors/{connectorId}:disable',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def enable_connector(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Enable a connector.

        Endpoint for enabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._enable_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def enable_connector_with_http_info(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Enable a connector.

        Endpoint for enabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._enable_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def enable_connector_without_preload_content(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Enable a connector.

        Endpoint for enabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._enable_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _enable_connector_serialize(
        self,
        connector_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/connectors/{connectorId}:enable',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_connector(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Connector:
        """Retrieve a connector.


        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Connector",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_connector_with_http_info(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Connector]:
        """Retrieve a connector.


        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Connector",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_connector_without_preload_content(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a connector.


        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_connector_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Connector",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_connector_serialize(
        self,
        connector_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/connectors/{connectorId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_connectors(
        self,
        active_only: Annotated[Optional[StrictBool], Field(description="When true only the active connectors will be returned. When false (default value) all connectors wil be returned.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ConnectorList:
        """Retrieve a list of connectors.


        :param active_only: When true only the active connectors will be returned. When false (default value) all connectors wil be returned.
        :type active_only: bool
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_connectors_serialize(
            active_only=active_only,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ConnectorList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_connectors_with_http_info(
        self,
        active_only: Annotated[Optional[StrictBool], Field(description="When true only the active connectors will be returned. When false (default value) all connectors wil be returned.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ConnectorList]:
        """Retrieve a list of connectors.


        :param active_only: When true only the active connectors will be returned. When false (default value) all connectors wil be returned.
        :type active_only: bool
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_connectors_serialize(
            active_only=active_only,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ConnectorList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_connectors_without_preload_content(
        self,
        active_only: Annotated[Optional[StrictBool], Field(description="When true only the active connectors will be returned. When false (default value) all connectors wil be returned.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of connectors.


        :param active_only: When true only the active connectors will be returned. When false (default value) all connectors wil be returned.
        :type active_only: bool
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_connectors_serialize(
            active_only=active_only,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ConnectorList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_connectors_serialize(
        self,
        active_only,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if active_only is not None:
            
            _query_params.append(('activeOnly', active_only))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/connectors',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_download_rule(
        self,
        connector_id: StrictStr,
        download_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DownloadRule:
        """Retrieve a download rule.


        :param connector_id: (required)
        :type connector_id: str
        :param download_rule_id: (required)
        :type download_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_download_rule_serialize(
            connector_id=connector_id,
            download_rule_id=download_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DownloadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_download_rule_with_http_info(
        self,
        connector_id: StrictStr,
        download_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DownloadRule]:
        """Retrieve a download rule.


        :param connector_id: (required)
        :type connector_id: str
        :param download_rule_id: (required)
        :type download_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_download_rule_serialize(
            connector_id=connector_id,
            download_rule_id=download_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DownloadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_download_rule_without_preload_content(
        self,
        connector_id: StrictStr,
        download_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a download rule.


        :param connector_id: (required)
        :type connector_id: str
        :param download_rule_id: (required)
        :type download_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_download_rule_serialize(
            connector_id=connector_id,
            download_rule_id=download_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DownloadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_download_rule_serialize(
        self,
        connector_id,
        download_rule_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        if download_rule_id is not None:
            _path_params['downloadRuleId'] = download_rule_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/connectors/{connectorId}/downloadRules/{downloadRuleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_download_rules(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DownloadRuleList:
        """Retrieve a list of download rules.


        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_download_rules_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DownloadRuleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_download_rules_with_http_info(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DownloadRuleList]:
        """Retrieve a list of download rules.


        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_download_rules_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DownloadRuleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_download_rules_without_preload_content(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of download rules.


        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_download_rules_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DownloadRuleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_download_rules_serialize(
        self,
        connector_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/connectors/{connectorId}/downloadRules',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_upload_rule(
        self,
        connector_id: StrictStr,
        upload_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> UploadRule:
        """Retrieve an upload rule.


        :param connector_id: (required)
        :type connector_id: str
        :param upload_rule_id: (required)
        :type upload_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_upload_rule_serialize(
            connector_id=connector_id,
            upload_rule_id=upload_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UploadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_upload_rule_with_http_info(
        self,
        connector_id: StrictStr,
        upload_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[UploadRule]:
        """Retrieve an upload rule.


        :param connector_id: (required)
        :type connector_id: str
        :param upload_rule_id: (required)
        :type upload_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_upload_rule_serialize(
            connector_id=connector_id,
            upload_rule_id=upload_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UploadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_upload_rule_without_preload_content(
        self,
        connector_id: StrictStr,
        upload_rule_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve an upload rule.


        :param connector_id: (required)
        :type connector_id: str
        :param upload_rule_id: (required)
        :type upload_rule_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_upload_rule_serialize(
            connector_id=connector_id,
            upload_rule_id=upload_rule_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UploadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_upload_rule_serialize(
        self,
        connector_id,
        upload_rule_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        if upload_rule_id is not None:
            _path_params['uploadRuleId'] = upload_rule_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/connectors/{connectorId}/uploadRules/{uploadRuleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_upload_rules(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> UploadRuleList:
        """Retrieve a list of upload rules.


        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_upload_rules_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UploadRuleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_upload_rules_with_http_info(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[UploadRuleList]:
        """Retrieve a list of upload rules.


        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_upload_rules_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UploadRuleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_upload_rules_without_preload_content(
        self,
        connector_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of upload rules.


        :param connector_id: (required)
        :type connector_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_upload_rules_serialize(
            connector_id=connector_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UploadRuleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_upload_rules_serialize(
        self,
        connector_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/connectors/{connectorId}/uploadRules',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_download_rule(
        self,
        connector_id: StrictStr,
        download_rule_id: StrictStr,
        download_rule: Annotated[DownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DownloadRule:
        """Update a download rule.

        Fields which can be updated:  - code  - active  - description  - sequence  - formatCode  - projectName  - targetLocalFolder  - protocol  - fileNameExpression  - disableHashing

        :param connector_id: (required)
        :type connector_id: str
        :param download_rule_id: (required)
        :type download_rule_id: str
        :param download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type download_rule: DownloadRule
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_download_rule_serialize(
            connector_id=connector_id,
            download_rule_id=download_rule_id,
            download_rule=download_rule,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DownloadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_download_rule_with_http_info(
        self,
        connector_id: StrictStr,
        download_rule_id: StrictStr,
        download_rule: Annotated[DownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DownloadRule]:
        """Update a download rule.

        Fields which can be updated:  - code  - active  - description  - sequence  - formatCode  - projectName  - targetLocalFolder  - protocol  - fileNameExpression  - disableHashing

        :param connector_id: (required)
        :type connector_id: str
        :param download_rule_id: (required)
        :type download_rule_id: str
        :param download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type download_rule: DownloadRule
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_download_rule_serialize(
            connector_id=connector_id,
            download_rule_id=download_rule_id,
            download_rule=download_rule,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DownloadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_download_rule_without_preload_content(
        self,
        connector_id: StrictStr,
        download_rule_id: StrictStr,
        download_rule: Annotated[DownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a download rule.

        Fields which can be updated:  - code  - active  - description  - sequence  - formatCode  - projectName  - targetLocalFolder  - protocol  - fileNameExpression  - disableHashing

        :param connector_id: (required)
        :type connector_id: str
        :param download_rule_id: (required)
        :type download_rule_id: str
        :param download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type download_rule: DownloadRule
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_download_rule_serialize(
            connector_id=connector_id,
            download_rule_id=download_rule_id,
            download_rule=download_rule,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DownloadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_download_rule_serialize(
        self,
        connector_id,
        download_rule_id,
        download_rule,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        if download_rule_id is not None:
            _path_params['downloadRuleId'] = download_rule_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if download_rule is not None:
            _body_params = download_rule


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/connectors/{connectorId}/downloadRules/{downloadRuleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_upload_rule(
        self,
        connector_id: StrictStr,
        upload_rule_id: StrictStr,
        upload_rule: Annotated[UploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> UploadRule:
        """Update an upload rule.

        Fields which can be updated:  - code  - active  - description  - localFolder  - filePattern  - dataFormat 

        :param connector_id: (required)
        :type connector_id: str
        :param upload_rule_id: (required)
        :type upload_rule_id: str
        :param upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type upload_rule: UploadRule
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_upload_rule_serialize(
            connector_id=connector_id,
            upload_rule_id=upload_rule_id,
            upload_rule=upload_rule,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UploadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_upload_rule_with_http_info(
        self,
        connector_id: StrictStr,
        upload_rule_id: StrictStr,
        upload_rule: Annotated[UploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[UploadRule]:
        """Update an upload rule.

        Fields which can be updated:  - code  - active  - description  - localFolder  - filePattern  - dataFormat 

        :param connector_id: (required)
        :type connector_id: str
        :param upload_rule_id: (required)
        :type upload_rule_id: str
        :param upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type upload_rule: UploadRule
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_upload_rule_serialize(
            connector_id=connector_id,
            upload_rule_id=upload_rule_id,
            upload_rule=upload_rule,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UploadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_upload_rule_without_preload_content(
        self,
        connector_id: StrictStr,
        upload_rule_id: StrictStr,
        upload_rule: Annotated[UploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update an upload rule.

        Fields which can be updated:  - code  - active  - description  - localFolder  - filePattern  - dataFormat 

        :param connector_id: (required)
        :type connector_id: str
        :param upload_rule_id: (required)
        :type upload_rule_id: str
        :param upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
        :type upload_rule: UploadRule
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_upload_rule_serialize(
            connector_id=connector_id,
            upload_rule_id=upload_rule_id,
            upload_rule=upload_rule,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UploadRule",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_upload_rule_serialize(
        self,
        connector_id,
        upload_rule_id,
        upload_rule,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if connector_id is not None:
            _path_params['connectorId'] = connector_id
        if upload_rule_id is not None:
            _path_params['uploadRuleId'] = upload_rule_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if upload_rule is not None:
            _body_params = upload_rule


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/connectors/{connectorId}/uploadRules/{uploadRuleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def cancel_connector(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def cancel_connector(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Cancel a connector.

    Endpoint for cancelling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._cancel_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Cancel a connector.

Endpoint for cancelling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def cancel_connector_with_http_info(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def cancel_connector_with_http_info(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Cancel a connector.

    Endpoint for cancelling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._cancel_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Cancel a connector.

Endpoint for cancelling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def cancel_connector_without_preload_content(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def cancel_connector_without_preload_content(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Cancel a connector.

    Endpoint for cancelling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._cancel_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Cancel a connector.

Endpoint for cancelling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_connector(self,
create_connector: Annotated[CreateConnector, FieldInfo(annotation=NoneType, required=True, description='The connector to create.')]) ‑> Connector

Expand source code

@validate_call
def create_connector(
    self,
    create_connector: Annotated[CreateConnector, Field(description="The connector to create.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Connector:
    """Create a connector.


    :param create_connector: The connector to create. (required)
    :type create_connector: CreateConnector
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_connector_serialize(
        create_connector=create_connector,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "Connector",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a connector.

:param create_connector: The connector to create. (required) :type create_connector: CreateConnector :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_connector_with_http_info(self,
create_connector: Annotated[CreateConnector, FieldInfo(annotation=NoneType, required=True, description='The connector to create.')]) ‑> ApiResponse[Connector]

Expand source code

@validate_call
def create_connector_with_http_info(
    self,
    create_connector: Annotated[CreateConnector, Field(description="The connector to create.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Connector]:
    """Create a connector.


    :param create_connector: The connector to create. (required)
    :type create_connector: CreateConnector
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_connector_serialize(
        create_connector=create_connector,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "Connector",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a connector.

:param create_connector: The connector to create. (required) :type create_connector: CreateConnector :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_connector_without_preload_content(self,
create_connector: Annotated[CreateConnector, FieldInfo(annotation=NoneType, required=True, description='The connector to create.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_connector_without_preload_content(
    self,
    create_connector: Annotated[CreateConnector, Field(description="The connector to create.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a connector.


    :param create_connector: The connector to create. (required)
    :type create_connector: CreateConnector
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_connector_serialize(
        create_connector=create_connector,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "Connector",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a connector.

:param create_connector: The connector to create. (required) :type create_connector: CreateConnector :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_rule(self,
connector_id: Annotated[str, Strict(strict=True)],
create_download_rule: Annotated[CreateDownloadRule, FieldInfo(annotation=NoneType, required=True, description='The target local folder where to write the data. Leading or trailing spaces are not accepted.')]) ‑> DownloadRule

Expand source code

@validate_call
def create_download_rule(
    self,
    connector_id: StrictStr,
    create_download_rule: Annotated[CreateDownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DownloadRule:
    """Create a download rule.


    :param connector_id: (required)
    :type connector_id: str
    :param create_download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type create_download_rule: CreateDownloadRule
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_rule_serialize(
        connector_id=connector_id,
        create_download_rule=create_download_rule,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "DownloadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a download rule.

:param connector_id: (required) :type connector_id: str :param create_download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type create_download_rule: CreateDownloadRule :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_rule_with_http_info(self,
connector_id: Annotated[str, Strict(strict=True)],
create_download_rule: Annotated[CreateDownloadRule, FieldInfo(annotation=NoneType, required=True, description='The target local folder where to write the data. Leading or trailing spaces are not accepted.')]) ‑> ApiResponse[DownloadRule]

Expand source code

@validate_call
def create_download_rule_with_http_info(
    self,
    connector_id: StrictStr,
    create_download_rule: Annotated[CreateDownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DownloadRule]:
    """Create a download rule.


    :param connector_id: (required)
    :type connector_id: str
    :param create_download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type create_download_rule: CreateDownloadRule
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_rule_serialize(
        connector_id=connector_id,
        create_download_rule=create_download_rule,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "DownloadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a download rule.

:param connector_id: (required) :type connector_id: str :param create_download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type create_download_rule: CreateDownloadRule :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_rule_without_preload_content(self,
connector_id: Annotated[str, Strict(strict=True)],
create_download_rule: Annotated[CreateDownloadRule, FieldInfo(annotation=NoneType, required=True, description='The target local folder where to write the data. Leading or trailing spaces are not accepted.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_download_rule_without_preload_content(
    self,
    connector_id: StrictStr,
    create_download_rule: Annotated[CreateDownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a download rule.


    :param connector_id: (required)
    :type connector_id: str
    :param create_download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type create_download_rule: CreateDownloadRule
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_rule_serialize(
        connector_id=connector_id,
        create_download_rule=create_download_rule,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "DownloadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a download rule.

:param connector_id: (required) :type connector_id: str :param create_download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type create_download_rule: CreateDownloadRule :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_upload_rule(self,
connector_id: Annotated[str, Strict(strict=True)],
create_upload_rule: Annotated[CreateUploadRule, FieldInfo(annotation=NoneType, required=True, description='The local folder where to write the data. Leading or trailing spaces are not accepted.')]) ‑> UploadRule

Expand source code

@validate_call
def create_upload_rule(
    self,
    connector_id: StrictStr,
    create_upload_rule: Annotated[CreateUploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> UploadRule:
    """Create an upload rule.


    :param connector_id: (required)
    :type connector_id: str
    :param create_upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type create_upload_rule: CreateUploadRule
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_upload_rule_serialize(
        connector_id=connector_id,
        create_upload_rule=create_upload_rule,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "UploadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create an upload rule.

:param connector_id: (required) :type connector_id: str :param create_upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type create_upload_rule: CreateUploadRule :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_upload_rule_with_http_info(self,
connector_id: Annotated[str, Strict(strict=True)],
create_upload_rule: Annotated[CreateUploadRule, FieldInfo(annotation=NoneType, required=True, description='The local folder where to write the data. Leading or trailing spaces are not accepted.')]) ‑> ApiResponse[UploadRule]

Expand source code

@validate_call
def create_upload_rule_with_http_info(
    self,
    connector_id: StrictStr,
    create_upload_rule: Annotated[CreateUploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[UploadRule]:
    """Create an upload rule.


    :param connector_id: (required)
    :type connector_id: str
    :param create_upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type create_upload_rule: CreateUploadRule
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_upload_rule_serialize(
        connector_id=connector_id,
        create_upload_rule=create_upload_rule,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "UploadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create an upload rule.

:param connector_id: (required) :type connector_id: str :param create_upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type create_upload_rule: CreateUploadRule :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_upload_rule_without_preload_content(self,
connector_id: Annotated[str, Strict(strict=True)],
create_upload_rule: Annotated[CreateUploadRule, FieldInfo(annotation=NoneType, required=True, description='The local folder where to write the data. Leading or trailing spaces are not accepted.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_upload_rule_without_preload_content(
    self,
    connector_id: StrictStr,
    create_upload_rule: Annotated[CreateUploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create an upload rule.


    :param connector_id: (required)
    :type connector_id: str
    :param create_upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type create_upload_rule: CreateUploadRule
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_upload_rule_serialize(
        connector_id=connector_id,
        create_upload_rule=create_upload_rule,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "UploadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create an upload rule.

:param connector_id: (required) :type connector_id: str :param create_upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type create_upload_rule: CreateUploadRule :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_download_rule(self,
connector_id: Annotated[str, Strict(strict=True)],
download_rule_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def delete_download_rule(
    self,
    connector_id: StrictStr,
    download_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete a download rule.


    :param connector_id: (required)
    :type connector_id: str
    :param download_rule_id: (required)
    :type download_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_download_rule_serialize(
        connector_id=connector_id,
        download_rule_id=download_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete a download rule.

:param connector_id: (required) :type connector_id: str :param download_rule_id: (required) :type download_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_download_rule_with_http_info(self,
connector_id: Annotated[str, Strict(strict=True)],
download_rule_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_download_rule_with_http_info(
    self,
    connector_id: StrictStr,
    download_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete a download rule.


    :param connector_id: (required)
    :type connector_id: str
    :param download_rule_id: (required)
    :type download_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_download_rule_serialize(
        connector_id=connector_id,
        download_rule_id=download_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete a download rule.

:param connector_id: (required) :type connector_id: str :param download_rule_id: (required) :type download_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_download_rule_without_preload_content(self,
connector_id: Annotated[str, Strict(strict=True)],
download_rule_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_download_rule_without_preload_content(
    self,
    connector_id: StrictStr,
    download_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete a download rule.


    :param connector_id: (required)
    :type connector_id: str
    :param download_rule_id: (required)
    :type download_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_download_rule_serialize(
        connector_id=connector_id,
        download_rule_id=download_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete a download rule.

:param connector_id: (required) :type connector_id: str :param download_rule_id: (required) :type download_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_upload_rule(self,
connector_id: Annotated[str, Strict(strict=True)],
upload_rule_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def delete_upload_rule(
    self,
    connector_id: StrictStr,
    upload_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete an upload rule.


    :param connector_id: (required)
    :type connector_id: str
    :param upload_rule_id: (required)
    :type upload_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_upload_rule_serialize(
        connector_id=connector_id,
        upload_rule_id=upload_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete an upload rule.

:param connector_id: (required) :type connector_id: str :param upload_rule_id: (required) :type upload_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_upload_rule_with_http_info(self,
connector_id: Annotated[str, Strict(strict=True)],
upload_rule_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_upload_rule_with_http_info(
    self,
    connector_id: StrictStr,
    upload_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete an upload rule.


    :param connector_id: (required)
    :type connector_id: str
    :param upload_rule_id: (required)
    :type upload_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_upload_rule_serialize(
        connector_id=connector_id,
        upload_rule_id=upload_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete an upload rule.

:param connector_id: (required) :type connector_id: str :param upload_rule_id: (required) :type upload_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_upload_rule_without_preload_content(self,
connector_id: Annotated[str, Strict(strict=True)],
upload_rule_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_upload_rule_without_preload_content(
    self,
    connector_id: StrictStr,
    upload_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete an upload rule.


    :param connector_id: (required)
    :type connector_id: str
    :param upload_rule_id: (required)
    :type upload_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_upload_rule_serialize(
        connector_id=connector_id,
        upload_rule_id=upload_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete an upload rule.

:param connector_id: (required) :type connector_id: str :param upload_rule_id: (required) :type upload_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def disable_connector(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def disable_connector(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Disable a connector.

    Endpoint for disabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._disable_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Disable a connector.

Endpoint for disabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def disable_connector_with_http_info(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def disable_connector_with_http_info(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Disable a connector.

    Endpoint for disabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._disable_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Disable a connector.

Endpoint for disabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def disable_connector_without_preload_content(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def disable_connector_without_preload_content(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Disable a connector.

    Endpoint for disabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._disable_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Disable a connector.

Endpoint for disabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def enable_connector(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def enable_connector(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Enable a connector.

    Endpoint for enabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._enable_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Enable a connector.

Endpoint for enabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def enable_connector_with_http_info(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def enable_connector_with_http_info(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Enable a connector.

    Endpoint for enabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._enable_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Enable a connector.

Endpoint for enabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def enable_connector_without_preload_content(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def enable_connector_without_preload_content(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Enable a connector.

    Endpoint for enabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._enable_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Enable a connector.

Endpoint for enabling a connector. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_connector(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> Connector

Expand source code

@validate_call
def get_connector(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Connector:
    """Retrieve a connector.


    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Connector",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a connector.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_connector_with_http_info(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[Connector]

Expand source code

@validate_call
def get_connector_with_http_info(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Connector]:
    """Retrieve a connector.


    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Connector",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a connector.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_connector_without_preload_content(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_connector_without_preload_content(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a connector.


    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_connector_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Connector",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a connector.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_connectors(self,
active_only: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When true only the active connectors will be returned. When false (default value) all connectors wil be returned.')] = None) ‑> ConnectorList

Expand source code

@validate_call
def get_connectors(
    self,
    active_only: Annotated[Optional[StrictBool], Field(description="When true only the active connectors will be returned. When false (default value) all connectors wil be returned.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ConnectorList:
    """Retrieve a list of connectors.


    :param active_only: When true only the active connectors will be returned. When false (default value) all connectors wil be returned.
    :type active_only: bool
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_connectors_serialize(
        active_only=active_only,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ConnectorList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of connectors.

:param active_only: When true only the active connectors will be returned. When false (default value) all connectors wil be returned. :type active_only: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_connectors_with_http_info(self,
active_only: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When true only the active connectors will be returned. When false (default value) all connectors wil be returned.')] = None) ‑> ApiResponse[ConnectorList]

Expand source code

@validate_call
def get_connectors_with_http_info(
    self,
    active_only: Annotated[Optional[StrictBool], Field(description="When true only the active connectors will be returned. When false (default value) all connectors wil be returned.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ConnectorList]:
    """Retrieve a list of connectors.


    :param active_only: When true only the active connectors will be returned. When false (default value) all connectors wil be returned.
    :type active_only: bool
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_connectors_serialize(
        active_only=active_only,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ConnectorList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of connectors.

:param active_only: When true only the active connectors will be returned. When false (default value) all connectors wil be returned. :type active_only: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_connectors_without_preload_content(self,
active_only: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When true only the active connectors will be returned. When false (default value) all connectors wil be returned.')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_connectors_without_preload_content(
    self,
    active_only: Annotated[Optional[StrictBool], Field(description="When true only the active connectors will be returned. When false (default value) all connectors wil be returned.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of connectors.


    :param active_only: When true only the active connectors will be returned. When false (default value) all connectors wil be returned.
    :type active_only: bool
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_connectors_serialize(
        active_only=active_only,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ConnectorList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of connectors.

:param active_only: When true only the active connectors will be returned. When false (default value) all connectors wil be returned. :type active_only: bool :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_download_rule(self,
connector_id: Annotated[str, Strict(strict=True)],
download_rule_id: Annotated[str, Strict(strict=True)]) ‑> DownloadRule

Expand source code

@validate_call
def get_download_rule(
    self,
    connector_id: StrictStr,
    download_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DownloadRule:
    """Retrieve a download rule.


    :param connector_id: (required)
    :type connector_id: str
    :param download_rule_id: (required)
    :type download_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_download_rule_serialize(
        connector_id=connector_id,
        download_rule_id=download_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DownloadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a download rule.

:param connector_id: (required) :type connector_id: str :param download_rule_id: (required) :type download_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_download_rule_with_http_info(self,
connector_id: Annotated[str, Strict(strict=True)],
download_rule_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[DownloadRule]

Expand source code

@validate_call
def get_download_rule_with_http_info(
    self,
    connector_id: StrictStr,
    download_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DownloadRule]:
    """Retrieve a download rule.


    :param connector_id: (required)
    :type connector_id: str
    :param download_rule_id: (required)
    :type download_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_download_rule_serialize(
        connector_id=connector_id,
        download_rule_id=download_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DownloadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a download rule.

:param connector_id: (required) :type connector_id: str :param download_rule_id: (required) :type download_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_download_rule_without_preload_content(self,
connector_id: Annotated[str, Strict(strict=True)],
download_rule_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_download_rule_without_preload_content(
    self,
    connector_id: StrictStr,
    download_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a download rule.


    :param connector_id: (required)
    :type connector_id: str
    :param download_rule_id: (required)
    :type download_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_download_rule_serialize(
        connector_id=connector_id,
        download_rule_id=download_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DownloadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a download rule.

:param connector_id: (required) :type connector_id: str :param download_rule_id: (required) :type download_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_download_rules(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> DownloadRuleList

Expand source code

@validate_call
def get_download_rules(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DownloadRuleList:
    """Retrieve a list of download rules.


    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_download_rules_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DownloadRuleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of download rules.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_download_rules_with_http_info(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[DownloadRuleList]

Expand source code

@validate_call
def get_download_rules_with_http_info(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DownloadRuleList]:
    """Retrieve a list of download rules.


    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_download_rules_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DownloadRuleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of download rules.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_download_rules_without_preload_content(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_download_rules_without_preload_content(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of download rules.


    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_download_rules_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DownloadRuleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of download rules.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_upload_rule(self,
connector_id: Annotated[str, Strict(strict=True)],
upload_rule_id: Annotated[str, Strict(strict=True)]) ‑> UploadRule

Expand source code

@validate_call
def get_upload_rule(
    self,
    connector_id: StrictStr,
    upload_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> UploadRule:
    """Retrieve an upload rule.


    :param connector_id: (required)
    :type connector_id: str
    :param upload_rule_id: (required)
    :type upload_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_upload_rule_serialize(
        connector_id=connector_id,
        upload_rule_id=upload_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UploadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve an upload rule.

:param connector_id: (required) :type connector_id: str :param upload_rule_id: (required) :type upload_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_upload_rule_with_http_info(self,
connector_id: Annotated[str, Strict(strict=True)],
upload_rule_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[UploadRule]

Expand source code

@validate_call
def get_upload_rule_with_http_info(
    self,
    connector_id: StrictStr,
    upload_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[UploadRule]:
    """Retrieve an upload rule.


    :param connector_id: (required)
    :type connector_id: str
    :param upload_rule_id: (required)
    :type upload_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_upload_rule_serialize(
        connector_id=connector_id,
        upload_rule_id=upload_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UploadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve an upload rule.

:param connector_id: (required) :type connector_id: str :param upload_rule_id: (required) :type upload_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_upload_rule_without_preload_content(self,
connector_id: Annotated[str, Strict(strict=True)],
upload_rule_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_upload_rule_without_preload_content(
    self,
    connector_id: StrictStr,
    upload_rule_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve an upload rule.


    :param connector_id: (required)
    :type connector_id: str
    :param upload_rule_id: (required)
    :type upload_rule_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_upload_rule_serialize(
        connector_id=connector_id,
        upload_rule_id=upload_rule_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UploadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve an upload rule.

:param connector_id: (required) :type connector_id: str :param upload_rule_id: (required) :type upload_rule_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_upload_rules(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> UploadRuleList

Expand source code

@validate_call
def get_upload_rules(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> UploadRuleList:
    """Retrieve a list of upload rules.


    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_upload_rules_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UploadRuleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of upload rules.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_upload_rules_with_http_info(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[UploadRuleList]

Expand source code

@validate_call
def get_upload_rules_with_http_info(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[UploadRuleList]:
    """Retrieve a list of upload rules.


    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_upload_rules_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UploadRuleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of upload rules.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_upload_rules_without_preload_content(self, connector_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_upload_rules_without_preload_content(
    self,
    connector_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of upload rules.


    :param connector_id: (required)
    :type connector_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_upload_rules_serialize(
        connector_id=connector_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UploadRuleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of upload rules.

:param connector_id: (required) :type connector_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_download_rule(self,
connector_id: Annotated[str, Strict(strict=True)],
download_rule_id: Annotated[str, Strict(strict=True)],
download_rule: Annotated[DownloadRule, FieldInfo(annotation=NoneType, required=True, description='The target local folder where to write the data. Leading or trailing spaces are not accepted.')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> DownloadRule

Expand source code

@validate_call
def update_download_rule(
    self,
    connector_id: StrictStr,
    download_rule_id: StrictStr,
    download_rule: Annotated[DownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DownloadRule:
    """Update a download rule.

    Fields which can be updated:  - code  - active  - description  - sequence  - formatCode  - projectName  - targetLocalFolder  - protocol  - fileNameExpression  - disableHashing

    :param connector_id: (required)
    :type connector_id: str
    :param download_rule_id: (required)
    :type download_rule_id: str
    :param download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type download_rule: DownloadRule
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_download_rule_serialize(
        connector_id=connector_id,
        download_rule_id=download_rule_id,
        download_rule=download_rule,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DownloadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update a download rule.

Fields which can be updated: - code - active - description - sequence - formatCode - projectName - targetLocalFolder - protocol - fileNameExpression - disableHashing

:param connector_id: (required) :type connector_id: str :param download_rule_id: (required) :type download_rule_id: str :param download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type download_rule: DownloadRule :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_download_rule_with_http_info(self,
connector_id: Annotated[str, Strict(strict=True)],
download_rule_id: Annotated[str, Strict(strict=True)],
download_rule: Annotated[DownloadRule, FieldInfo(annotation=NoneType, required=True, description='The target local folder where to write the data. Leading or trailing spaces are not accepted.')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[DownloadRule]

Expand source code

@validate_call
def update_download_rule_with_http_info(
    self,
    connector_id: StrictStr,
    download_rule_id: StrictStr,
    download_rule: Annotated[DownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DownloadRule]:
    """Update a download rule.

    Fields which can be updated:  - code  - active  - description  - sequence  - formatCode  - projectName  - targetLocalFolder  - protocol  - fileNameExpression  - disableHashing

    :param connector_id: (required)
    :type connector_id: str
    :param download_rule_id: (required)
    :type download_rule_id: str
    :param download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type download_rule: DownloadRule
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_download_rule_serialize(
        connector_id=connector_id,
        download_rule_id=download_rule_id,
        download_rule=download_rule,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DownloadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update a download rule.

Fields which can be updated: - code - active - description - sequence - formatCode - projectName - targetLocalFolder - protocol - fileNameExpression - disableHashing

:param connector_id: (required) :type connector_id: str :param download_rule_id: (required) :type download_rule_id: str :param download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type download_rule: DownloadRule :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_download_rule_without_preload_content(self,
connector_id: Annotated[str, Strict(strict=True)],
download_rule_id: Annotated[str, Strict(strict=True)],
download_rule: Annotated[DownloadRule, FieldInfo(annotation=NoneType, required=True, description='The target local folder where to write the data. Leading or trailing spaces are not accepted.')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_download_rule_without_preload_content(
    self,
    connector_id: StrictStr,
    download_rule_id: StrictStr,
    download_rule: Annotated[DownloadRule, Field(description="The target local folder where to write the data. Leading or trailing spaces are not accepted.")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update a download rule.

    Fields which can be updated:  - code  - active  - description  - sequence  - formatCode  - projectName  - targetLocalFolder  - protocol  - fileNameExpression  - disableHashing

    :param connector_id: (required)
    :type connector_id: str
    :param download_rule_id: (required)
    :type download_rule_id: str
    :param download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type download_rule: DownloadRule
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_download_rule_serialize(
        connector_id=connector_id,
        download_rule_id=download_rule_id,
        download_rule=download_rule,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DownloadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update a download rule.

Fields which can be updated: - code - active - description - sequence - formatCode - projectName - targetLocalFolder - protocol - fileNameExpression - disableHashing

:param connector_id: (required) :type connector_id: str :param download_rule_id: (required) :type download_rule_id: str :param download_rule: The target local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type download_rule: DownloadRule :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_upload_rule(self,
connector_id: Annotated[str, Strict(strict=True)],
upload_rule_id: Annotated[str, Strict(strict=True)],
upload_rule: Annotated[UploadRule, FieldInfo(annotation=NoneType, required=True, description='The local folder where to write the data. Leading or trailing spaces are not accepted.')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> UploadRule

Expand source code

@validate_call
def update_upload_rule(
    self,
    connector_id: StrictStr,
    upload_rule_id: StrictStr,
    upload_rule: Annotated[UploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> UploadRule:
    """Update an upload rule.

    Fields which can be updated:  - code  - active  - description  - localFolder  - filePattern  - dataFormat 

    :param connector_id: (required)
    :type connector_id: str
    :param upload_rule_id: (required)
    :type upload_rule_id: str
    :param upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type upload_rule: UploadRule
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_upload_rule_serialize(
        connector_id=connector_id,
        upload_rule_id=upload_rule_id,
        upload_rule=upload_rule,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UploadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update an upload rule.

Fields which can be updated: - code - active - description - localFolder - filePattern - dataFormat

:param connector_id: (required) :type connector_id: str :param upload_rule_id: (required) :type upload_rule_id: str :param upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type upload_rule: UploadRule :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_upload_rule_with_http_info(self,
connector_id: Annotated[str, Strict(strict=True)],
upload_rule_id: Annotated[str, Strict(strict=True)],
upload_rule: Annotated[UploadRule, FieldInfo(annotation=NoneType, required=True, description='The local folder where to write the data. Leading or trailing spaces are not accepted.')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[UploadRule]

Expand source code

@validate_call
def update_upload_rule_with_http_info(
    self,
    connector_id: StrictStr,
    upload_rule_id: StrictStr,
    upload_rule: Annotated[UploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[UploadRule]:
    """Update an upload rule.

    Fields which can be updated:  - code  - active  - description  - localFolder  - filePattern  - dataFormat 

    :param connector_id: (required)
    :type connector_id: str
    :param upload_rule_id: (required)
    :type upload_rule_id: str
    :param upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type upload_rule: UploadRule
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_upload_rule_serialize(
        connector_id=connector_id,
        upload_rule_id=upload_rule_id,
        upload_rule=upload_rule,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UploadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update an upload rule.

Fields which can be updated: - code - active - description - localFolder - filePattern - dataFormat

:param connector_id: (required) :type connector_id: str :param upload_rule_id: (required) :type upload_rule_id: str :param upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type upload_rule: UploadRule :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_upload_rule_without_preload_content(self,
connector_id: Annotated[str, Strict(strict=True)],
upload_rule_id: Annotated[str, Strict(strict=True)],
upload_rule: Annotated[UploadRule, FieldInfo(annotation=NoneType, required=True, description='The local folder where to write the data. Leading or trailing spaces are not accepted.')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_upload_rule_without_preload_content(
    self,
    connector_id: StrictStr,
    upload_rule_id: StrictStr,
    upload_rule: Annotated[UploadRule, Field(description="The local folder where to write the data. Leading or trailing spaces are not accepted.")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update an upload rule.

    Fields which can be updated:  - code  - active  - description  - localFolder  - filePattern  - dataFormat 

    :param connector_id: (required)
    :type connector_id: str
    :param upload_rule_id: (required)
    :type upload_rule_id: str
    :param upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required)
    :type upload_rule: UploadRule
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_upload_rule_serialize(
        connector_id=connector_id,
        upload_rule_id=upload_rule_id,
        upload_rule=upload_rule,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UploadRule",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update an upload rule.

Fields which can be updated: - code - active - description - localFolder - filePattern - dataFormat

:param connector_id: (required) :type connector_id: str :param upload_rule_id: (required) :type upload_rule_id: str :param upload_rule: The local folder where to write the data. Leading or trailing spaces are not accepted. (required) :type upload_rule: UploadRule :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ConnectorList (**data: Any)

Expand source code

class ConnectorList(BaseModel):
    """
    ConnectorList
    """ # noqa: E501
    items: List[Optional[Connector]]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ConnectorList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ConnectorList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Connector.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ConnectorList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Connector | None]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ConnectorList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ConnectorList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Country (**data: Any)

Expand source code

class Country(BaseModel):
    """
    Country
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    code: StrictStr = Field(description="The country code as defined by ISO.")
    name: StrictStr = Field(description="The full name of the country.")
    region: StrictStr = Field(description="The region where the country belong to.")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "code", "name", "region"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Country from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Country from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "code": obj.get("code"),
            "name": obj.get("name"),
            "region": obj.get("region")
        })
        return _obj

Country

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var region : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Country from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Country from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateAnalysisCreationBatch (**data: Any)

Expand source code

class CreateAnalysisCreationBatch(BaseModel):
    """
    CreateAnalysisCreationBatch
    """ # noqa: E501
    cwl_items: Optional[List[CreateCwlAnalysis]] = Field(default=None, alias="cwlItems")
    nextflow_items: Optional[List[CreateNextflowAnalysis]] = Field(default=None, alias="nextflowItems")
    nextflow_json_items: Optional[List[CreateNextflowJsonAnalysis]] = Field(default=None, alias="nextflowJsonItems")
    __properties: ClassVar[List[str]] = ["cwlItems", "nextflowItems", "nextflowJsonItems"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateAnalysisCreationBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in cwl_items (list)
        _items = []
        if self.cwl_items:
            for _item_cwl_items in self.cwl_items:
                if _item_cwl_items:
                    _items.append(_item_cwl_items.to_dict())
            _dict['cwlItems'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in nextflow_items (list)
        _items = []
        if self.nextflow_items:
            for _item_nextflow_items in self.nextflow_items:
                if _item_nextflow_items:
                    _items.append(_item_nextflow_items.to_dict())
            _dict['nextflowItems'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in nextflow_json_items (list)
        _items = []
        if self.nextflow_json_items:
            for _item_nextflow_json_items in self.nextflow_json_items:
                if _item_nextflow_json_items:
                    _items.append(_item_nextflow_json_items.to_dict())
            _dict['nextflowJsonItems'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateAnalysisCreationBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "cwlItems": [CreateCwlAnalysis.from_dict(_item) for _item in obj["cwlItems"]] if obj.get("cwlItems") is not None else None,
            "nextflowItems": [CreateNextflowAnalysis.from_dict(_item) for _item in obj["nextflowItems"]] if obj.get("nextflowItems") is not None else None,
            "nextflowJsonItems": [CreateNextflowJsonAnalysis.from_dict(_item) for _item in obj["nextflowJsonItems"]] if obj.get("nextflowJsonItems") is not None else None
        })
        return _obj

CreateAnalysisCreationBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var cwl_items : List[CreateCwlAnalysis] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var nextflow_items : List[CreateNextflowAnalysis] | None

The type of the None singleton.

var nextflow_json_items : List[CreateNextflowJsonAnalysis] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateAnalysisCreationBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateAnalysisCreationBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in cwl_items (list)
    _items = []
    if self.cwl_items:
        for _item_cwl_items in self.cwl_items:
            if _item_cwl_items:
                _items.append(_item_cwl_items.to_dict())
        _dict['cwlItems'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in nextflow_items (list)
    _items = []
    if self.nextflow_items:
        for _item_nextflow_items in self.nextflow_items:
            if _item_nextflow_items:
                _items.append(_item_nextflow_items.to_dict())
        _dict['nextflowItems'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in nextflow_json_items (list)
    _items = []
    if self.nextflow_json_items:
        for _item_nextflow_json_items in self.nextflow_json_items:
            if _item_nextflow_json_items:
                _items.append(_item_nextflow_json_items.to_dict())
        _dict['nextflowJsonItems'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateAnalysisTag (**data: Any)

Expand source code

class CreateAnalysisTag(BaseModel):
    """
    CreateAnalysisTag
    """ # noqa: E501
    technical_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="Technical tags", alias="technicalTags")
    user_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="User tags", alias="userTags")
    reference_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="Reference tags", alias="referenceTags")
    __properties: ClassVar[List[str]] = ["technicalTags", "userTags", "referenceTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateAnalysisTag from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if technical_tags (nullable) is None
        # and model_fields_set contains the field
        if self.technical_tags is None and "technical_tags" in self.model_fields_set:
            _dict['technicalTags'] = None

        # set to None if user_tags (nullable) is None
        # and model_fields_set contains the field
        if self.user_tags is None and "user_tags" in self.model_fields_set:
            _dict['userTags'] = None

        # set to None if reference_tags (nullable) is None
        # and model_fields_set contains the field
        if self.reference_tags is None and "reference_tags" in self.model_fields_set:
            _dict['referenceTags'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateAnalysisTag from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "technicalTags": obj.get("technicalTags"),
            "userTags": obj.get("userTags"),
            "referenceTags": obj.get("referenceTags")
        })
        return _obj

CreateAnalysisTag

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var reference_tags : List[str | None] | None

The type of the None singleton.

var technical_tags : List[str | None] | None

The type of the None singleton.

var user_tags : List[str | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateAnalysisTag from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateAnalysisTag from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if technical_tags (nullable) is None
    # and model_fields_set contains the field
    if self.technical_tags is None and "technical_tags" in self.model_fields_set:
        _dict['technicalTags'] = None

    # set to None if user_tags (nullable) is None
    # and model_fields_set contains the field
    if self.user_tags is None and "user_tags" in self.model_fields_set:
        _dict['userTags'] = None

    # set to None if reference_tags (nullable) is None
    # and model_fields_set contains the field
    if self.reference_tags is None and "reference_tags" in self.model_fields_set:
        _dict['referenceTags'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateBundle (**data: Any)

Expand source code

class CreateBundle(BaseModel):
    """
    CreateBundle
    """ # noqa: E501
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    short_description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = Field(default=None, alias="shortDescription")
    bundle_release_version: StrictStr = Field(alias="bundleReleaseVersion")
    bundle_version_comment: Optional[StrictStr] = Field(default=None, alias="bundleVersionComment")
    region_id: StrictStr = Field(alias="regionId")
    metadata_model_id: Optional[StrictStr] = Field(default=None, alias="metadataModelId")
    bundle_status: StrictStr = Field(alias="bundleStatus")
    categories: List[StrictStr] = Field(description="category tags as string array")
    links: Optional[Links] = None
    __properties: ClassVar[List[str]] = ["name", "shortDescription", "bundleReleaseVersion", "bundleVersionComment", "regionId", "metadataModelId", "bundleStatus", "categories", "links"]

    @field_validator('bundle_status')
    def bundle_status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['DRAFT', 'RELEASED', 'DEPRECATED']):
            raise ValueError("must be one of enum values ('DRAFT', 'RELEASED', 'DEPRECATED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateBundle from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of links
        if self.links:
            _dict['links'] = self.links.to_dict()
        # set to None if short_description (nullable) is None
        # and model_fields_set contains the field
        if self.short_description is None and "short_description" in self.model_fields_set:
            _dict['shortDescription'] = None

        # set to None if bundle_version_comment (nullable) is None
        # and model_fields_set contains the field
        if self.bundle_version_comment is None and "bundle_version_comment" in self.model_fields_set:
            _dict['bundleVersionComment'] = None

        # set to None if metadata_model_id (nullable) is None
        # and model_fields_set contains the field
        if self.metadata_model_id is None and "metadata_model_id" in self.model_fields_set:
            _dict['metadataModelId'] = None

        # set to None if links (nullable) is None
        # and model_fields_set contains the field
        if self.links is None and "links" in self.model_fields_set:
            _dict['links'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateBundle from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "shortDescription": obj.get("shortDescription"),
            "bundleReleaseVersion": obj.get("bundleReleaseVersion"),
            "bundleVersionComment": obj.get("bundleVersionComment"),
            "regionId": obj.get("regionId"),
            "metadataModelId": obj.get("metadataModelId"),
            "bundleStatus": obj.get("bundleStatus"),
            "categories": obj.get("categories"),
            "links": Links.from_dict(obj["links"]) if obj.get("links") is not None else None
        })
        return _obj

CreateBundle

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bundle_release_version : str

The type of the None singleton.

var bundle_status : str

The type of the None singleton.

var bundle_version_comment : str | None

The type of the None singleton.

var categories : List[str]

The type of the None singleton.

var links : Links | None

The type of the None singleton.

var metadata_model_id : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var region_id : str

The type of the None singleton.

var short_description : str | None

The type of the None singleton.

Static methods

def bundle_status_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateBundle from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateBundle from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of links
    if self.links:
        _dict['links'] = self.links.to_dict()
    # set to None if short_description (nullable) is None
    # and model_fields_set contains the field
    if self.short_description is None and "short_description" in self.model_fields_set:
        _dict['shortDescription'] = None

    # set to None if bundle_version_comment (nullable) is None
    # and model_fields_set contains the field
    if self.bundle_version_comment is None and "bundle_version_comment" in self.model_fields_set:
        _dict['bundleVersionComment'] = None

    # set to None if metadata_model_id (nullable) is None
    # and model_fields_set contains the field
    if self.metadata_model_id is None and "metadata_model_id" in self.model_fields_set:
        _dict['metadataModelId'] = None

    # set to None if links (nullable) is None
    # and model_fields_set contains the field
    if self.links is None and "links" in self.model_fields_set:
        _dict['links'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateBundleDataLinkingBatch (**data: Any)

Expand source code

class CreateBundleDataLinkingBatch(BaseModel):
    """
    CreateBundleDataLinkingBatch
    """ # noqa: E501
    items: List[CreateBundleDataLinkingBatchItem]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateBundleDataLinkingBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateBundleDataLinkingBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [CreateBundleDataLinkingBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

CreateBundleDataLinkingBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[CreateBundleDataLinkingBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateBundleDataLinkingBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateBundleDataLinkingBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateBundleDataLinkingBatchItem (**data: Any)

Expand source code

class CreateBundleDataLinkingBatchItem(BaseModel):
    """
    CreateBundleDataLinkingBatchItem
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateBundleDataLinkingBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateBundleDataLinkingBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

CreateBundleDataLinkingBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateBundleDataLinkingBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateBundleDataLinkingBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateBundleDataUnlinkingBatch (**data: Any)

Expand source code

class CreateBundleDataUnlinkingBatch(BaseModel):
    """
    CreateBundleDataUnlinkingBatch
    """ # noqa: E501
    items: List[CreateBundleDataUnlinkingBatchItem]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateBundleDataUnlinkingBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateBundleDataUnlinkingBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [CreateBundleDataUnlinkingBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

CreateBundleDataUnlinkingBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[CreateBundleDataUnlinkingBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateBundleDataUnlinkingBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateBundleDataUnlinkingBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateBundleDataUnlinkingBatchItem (**data: Any)

Expand source code

class CreateBundleDataUnlinkingBatchItem(BaseModel):
    """
    CreateBundleDataUnlinkingBatchItem
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateBundleDataUnlinkingBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateBundleDataUnlinkingBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

CreateBundleDataUnlinkingBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateBundleDataUnlinkingBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateBundleDataUnlinkingBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateConnector (**data: Any)

Expand source code

class CreateConnector(BaseModel):
    """
    CreateConnector
    """ # noqa: E501
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    active: StrictBool
    description: Optional[StrictStr] = Field(default=None, description="The general description of the connector instance including its purpose.")
    mode: StrictStr = Field(description="The mode the connector runs in.")
    max_bandwidth: Optional[Union[Annotated[float, Field(strict=True, ge=0.01)], Annotated[int, Field(strict=True, ge=1)]]] = Field(default=None, description="The maximum bandwidth defined in MB per second.", alias="maxBandwidth")
    max_concurrent_transfers: Optional[Annotated[int, Field(strict=True, ge=1)]] = Field(default=2, description="The maximum amount of concurrent transfers that this connector can execute.", alias="maxConcurrentTransfers")
    os: StrictStr = Field(description="The target OS of the original connector installer.")
    __properties: ClassVar[List[str]] = ["code", "active", "description", "mode", "maxBandwidth", "maxConcurrentTransfers", "os"]

    @field_validator('mode')
    def mode_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['DOWNLOAD', 'UPLOAD', 'BOTH', 'NONE']):
            raise ValueError("must be one of enum values ('DOWNLOAD', 'UPLOAD', 'BOTH', 'NONE')")
        return value

    @field_validator('os')
    def os_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['WINDOWS', 'LINUX', 'OSX']):
            raise ValueError("must be one of enum values ('WINDOWS', 'LINUX', 'OSX')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateConnector from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if max_bandwidth (nullable) is None
        # and model_fields_set contains the field
        if self.max_bandwidth is None and "max_bandwidth" in self.model_fields_set:
            _dict['maxBandwidth'] = None

        # set to None if max_concurrent_transfers (nullable) is None
        # and model_fields_set contains the field
        if self.max_concurrent_transfers is None and "max_concurrent_transfers" in self.model_fields_set:
            _dict['maxConcurrentTransfers'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateConnector from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "active": obj.get("active"),
            "description": obj.get("description"),
            "mode": obj.get("mode"),
            "maxBandwidth": obj.get("maxBandwidth"),
            "maxConcurrentTransfers": obj.get("maxConcurrentTransfers") if obj.get("maxConcurrentTransfers") is not None else 2,
            "os": obj.get("os")
        })
        return _obj

CreateConnector

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var active : bool

The type of the None singleton.

var code : str

The type of the None singleton.

var description : str | None

The type of the None singleton.

var max_bandwidth : float | int | None

The type of the None singleton.

var max_concurrent_transfers : int | None

The type of the None singleton.

var mode : str

The type of the None singleton.

var model_config

The type of the None singleton.

var os : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateConnector from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateConnector from a JSON string

def mode_validate_enum(value)

Validates the enum

def os_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if max_bandwidth (nullable) is None
    # and model_fields_set contains the field
    if self.max_bandwidth is None and "max_bandwidth" in self.model_fields_set:
        _dict['maxBandwidth'] = None

    # set to None if max_concurrent_transfers (nullable) is None
    # and model_fields_set contains the field
    if self.max_concurrent_transfers is None and "max_concurrent_transfers" in self.model_fields_set:
        _dict['maxConcurrentTransfers'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateCustomEvent (**data: Any)

Expand source code

class CreateCustomEvent(BaseModel):
    """
    CreateCustomEvent
    """ # noqa: E501
    code: Annotated[str, Field(min_length=1, strict=True, max_length=50)] = Field(description="The event code that should match a custom subscription.")
    content: Dict[str, Any] = Field(description="The content that will be forwarded to the configured custom subscription destinations.")
    __properties: ClassVar[List[str]] = ["code", "content"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateCustomEvent from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateCustomEvent from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "content": obj.get("content")
        })
        return _obj

CreateCustomEvent

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str

The type of the None singleton.

var content : Dict[str, Any]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateCustomEvent from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateCustomEvent from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateCustomNotificationSubscription (**data: Any)

Expand source code

class CreateCustomNotificationSubscription(BaseModel):
    """
    CreateCustomNotificationSubscription
    """ # noqa: E501
    custom_event_code: Annotated[str, Field(min_length=1, strict=True, max_length=20)] = Field(description="The custom event code to subscribe to", alias="customEventCode")
    filter_expression: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=2000)]] = Field(default=None, description="To be used when a notification applies to specific conditions.", alias="filterExpression")
    enabled: StrictBool = Field(description="Should this subscription be enabled or not?")
    notification_channel_id: StrictStr = Field(description="The id of the notification channel used to send on", alias="notificationChannelId")
    __properties: ClassVar[List[str]] = ["customEventCode", "filterExpression", "enabled", "notificationChannelId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateCustomNotificationSubscription from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if filter_expression (nullable) is None
        # and model_fields_set contains the field
        if self.filter_expression is None and "filter_expression" in self.model_fields_set:
            _dict['filterExpression'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateCustomNotificationSubscription from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "customEventCode": obj.get("customEventCode"),
            "filterExpression": obj.get("filterExpression"),
            "enabled": obj.get("enabled"),
            "notificationChannelId": obj.get("notificationChannelId")
        })
        return _obj

CreateCustomNotificationSubscription

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var custom_event_code : str

The type of the None singleton.

var enabled : bool

The type of the None singleton.

var filter_expression : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var notification_channel_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateCustomNotificationSubscription from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateCustomNotificationSubscription from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if filter_expression (nullable) is None
    # and model_fields_set contains the field
    if self.filter_expression is None and "filter_expression" in self.model_fields_set:
        _dict['filterExpression'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateCwlAnalysis (**data: Any)

Expand source code

class CreateCwlAnalysis(BaseModel):
    """
    CreateCwlAnalysis
    """ # noqa: E501
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user-reference of the analysis. This should be something meaningful for the user.", alias="userReference")
    pipeline_id: StrictStr = Field(description="The pipeline for which an analysis will be created.", alias="pipelineId")
    tags: Optional[CreateAnalysisTag] = None
    analysis_storage_id: Optional[StrictStr] = Field(default=None, description="The id of the storage to use for the analysis.", alias="analysisStorageId")
    output_parent_folder_id: Optional[StrictStr] = Field(default=None, description="The id or the urn of the folder in which the output folder should be created.", alias="outputParentFolderId")
    analysis_output: Optional[List[Optional[AnalysisOutputMapping]]] = Field(default=None, alias="analysisOutput")
    analysis_input: CwlAnalysisInput = Field(alias="analysisInput")
    activation_code_detail_id: Optional[StrictStr] = Field(default=None, description="Indicates under which activation code the pipeline is executed.", alias="activationCodeDetailId")
    __properties: ClassVar[List[str]] = ["userReference", "pipelineId", "tags", "analysisStorageId", "outputParentFolderId", "analysisOutput", "analysisInput", "activationCodeDetailId"]

    @field_validator('user_reference')
    def user_reference_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$", value):
            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateCwlAnalysis from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
        _items = []
        if self.analysis_output:
            for _item_analysis_output in self.analysis_output:
                if _item_analysis_output:
                    _items.append(_item_analysis_output.to_dict())
            _dict['analysisOutput'] = _items
        # override the default output from pydantic by calling `to_dict()` of analysis_input
        if self.analysis_input:
            _dict['analysisInput'] = self.analysis_input.to_dict()
        # set to None if analysis_storage_id (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
            _dict['analysisStorageId'] = None

        # set to None if output_parent_folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
            _dict['outputParentFolderId'] = None

        # set to None if analysis_output (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_output is None and "analysis_output" in self.model_fields_set:
            _dict['analysisOutput'] = None

        # set to None if activation_code_detail_id (nullable) is None
        # and model_fields_set contains the field
        if self.activation_code_detail_id is None and "activation_code_detail_id" in self.model_fields_set:
            _dict['activationCodeDetailId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateCwlAnalysis from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "userReference": obj.get("userReference"),
            "pipelineId": obj.get("pipelineId"),
            "tags": CreateAnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "analysisStorageId": obj.get("analysisStorageId"),
            "outputParentFolderId": obj.get("outputParentFolderId"),
            "analysisOutput": [AnalysisOutputMapping.from_dict(_item) for _item in obj["analysisOutput"]] if obj.get("analysisOutput") is not None else None,
            "analysisInput": CwlAnalysisInput.from_dict(obj["analysisInput"]) if obj.get("analysisInput") is not None else None,
            "activationCodeDetailId": obj.get("activationCodeDetailId")
        })
        return _obj

CreateCwlAnalysis

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var activation_code_detail_id : str | None

The type of the None singleton.

var analysis_input : CwlAnalysisInput

The type of the None singleton.

var analysis_output : List[AnalysisOutputMapping | None] | None

The type of the None singleton.

var analysis_storage_id : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var output_parent_folder_id : str | None

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var tags : CreateAnalysisTag | None

The type of the None singleton.

var user_reference : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateCwlAnalysis from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateCwlAnalysis from a JSON string

def user_reference_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
    _items = []
    if self.analysis_output:
        for _item_analysis_output in self.analysis_output:
            if _item_analysis_output:
                _items.append(_item_analysis_output.to_dict())
        _dict['analysisOutput'] = _items
    # override the default output from pydantic by calling `to_dict()` of analysis_input
    if self.analysis_input:
        _dict['analysisInput'] = self.analysis_input.to_dict()
    # set to None if analysis_storage_id (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
        _dict['analysisStorageId'] = None

    # set to None if output_parent_folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
        _dict['outputParentFolderId'] = None

    # set to None if analysis_output (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_output is None and "analysis_output" in self.model_fields_set:
        _dict['analysisOutput'] = None

    # set to None if activation_code_detail_id (nullable) is None
    # and model_fields_set contains the field
    if self.activation_code_detail_id is None and "activation_code_detail_id" in self.model_fields_set:
        _dict['activationCodeDetailId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateCwlJsonAnalysis (**data: Any)

Expand source code

class CreateCwlJsonAnalysis(BaseModel):
    """
    CreateCwlJsonAnalysis
    """ # noqa: E501
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user-reference of the analysis. This should be something meaningful for the user.", alias="userReference")
    pipeline_id: StrictStr = Field(description="The pipeline for which an analysis will be created.", alias="pipelineId")
    tags: Optional[CreateAnalysisTag] = None
    analysis_storage_id: Optional[StrictStr] = Field(default=None, description="The id of the storage to use for the analysis.", alias="analysisStorageId")
    output_parent_folder_id: Optional[StrictStr] = Field(default=None, description="The id or the urn of the folder in which the output folder should be created.", alias="outputParentFolderId")
    analysis_output: Optional[List[Optional[AnalysisOutputMapping]]] = Field(default=None, alias="analysisOutput")
    input_form_values: CwlJsonAnalysisInput = Field(alias="inputFormValues")
    __properties: ClassVar[List[str]] = ["userReference", "pipelineId", "tags", "analysisStorageId", "outputParentFolderId", "analysisOutput", "inputFormValues"]

    @field_validator('user_reference')
    def user_reference_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$", value):
            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateCwlJsonAnalysis from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
        _items = []
        if self.analysis_output:
            for _item_analysis_output in self.analysis_output:
                if _item_analysis_output:
                    _items.append(_item_analysis_output.to_dict())
            _dict['analysisOutput'] = _items
        # override the default output from pydantic by calling `to_dict()` of input_form_values
        if self.input_form_values:
            _dict['inputFormValues'] = self.input_form_values.to_dict()
        # set to None if analysis_storage_id (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
            _dict['analysisStorageId'] = None

        # set to None if output_parent_folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
            _dict['outputParentFolderId'] = None

        # set to None if analysis_output (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_output is None and "analysis_output" in self.model_fields_set:
            _dict['analysisOutput'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateCwlJsonAnalysis from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "userReference": obj.get("userReference"),
            "pipelineId": obj.get("pipelineId"),
            "tags": CreateAnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "analysisStorageId": obj.get("analysisStorageId"),
            "outputParentFolderId": obj.get("outputParentFolderId"),
            "analysisOutput": [AnalysisOutputMapping.from_dict(_item) for _item in obj["analysisOutput"]] if obj.get("analysisOutput") is not None else None,
            "inputFormValues": CwlJsonAnalysisInput.from_dict(obj["inputFormValues"]) if obj.get("inputFormValues") is not None else None
        })
        return _obj

CreateCwlJsonAnalysis

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_output : List[AnalysisOutputMapping | None] | None

The type of the None singleton.

var analysis_storage_id : str | None

The type of the None singleton.

var input_form_values : CwlJsonAnalysisInput

The type of the None singleton.

var model_config

The type of the None singleton.

var output_parent_folder_id : str | None

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var tags : CreateAnalysisTag | None

The type of the None singleton.

var user_reference : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateCwlJsonAnalysis from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateCwlJsonAnalysis from a JSON string

def user_reference_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
    _items = []
    if self.analysis_output:
        for _item_analysis_output in self.analysis_output:
            if _item_analysis_output:
                _items.append(_item_analysis_output.to_dict())
        _dict['analysisOutput'] = _items
    # override the default output from pydantic by calling `to_dict()` of input_form_values
    if self.input_form_values:
        _dict['inputFormValues'] = self.input_form_values.to_dict()
    # set to None if analysis_storage_id (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
        _dict['analysisStorageId'] = None

    # set to None if output_parent_folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
        _dict['outputParentFolderId'] = None

    # set to None if analysis_output (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_output is None and "analysis_output" in self.model_fields_set:
        _dict['analysisOutput'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateCwlWithJsonInputAnalysis (**data: Any)

Expand source code

class CreateCwlWithJsonInputAnalysis(BaseModel):
    """
    CreateCwlWithJsonInputAnalysis
    """ # noqa: E501
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user-reference of the analysis. This should be something meaningful for the user.", alias="userReference")
    pipeline_id: StrictStr = Field(description="The pipeline for which an analysis will be created.", alias="pipelineId")
    tags: Optional[CreateAnalysisTag] = None
    analysis_storage_id: Optional[StrictStr] = Field(default=None, description="The id of the storage to use for the analysis.", alias="analysisStorageId")
    output_parent_folder_id: Optional[StrictStr] = Field(default=None, description="The id or the urn of the folder in which the output folder should be created.", alias="outputParentFolderId")
    analysis_output: Optional[List[Optional[AnalysisOutputMapping]]] = Field(default=None, alias="analysisOutput")
    analysis_input: CwlAnalysisWithJsonInput = Field(alias="analysisInput")
    __properties: ClassVar[List[str]] = ["userReference", "pipelineId", "tags", "analysisStorageId", "outputParentFolderId", "analysisOutput", "analysisInput"]

    @field_validator('user_reference')
    def user_reference_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$", value):
            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateCwlWithJsonInputAnalysis from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
        _items = []
        if self.analysis_output:
            for _item_analysis_output in self.analysis_output:
                if _item_analysis_output:
                    _items.append(_item_analysis_output.to_dict())
            _dict['analysisOutput'] = _items
        # override the default output from pydantic by calling `to_dict()` of analysis_input
        if self.analysis_input:
            _dict['analysisInput'] = self.analysis_input.to_dict()
        # set to None if analysis_storage_id (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
            _dict['analysisStorageId'] = None

        # set to None if output_parent_folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
            _dict['outputParentFolderId'] = None

        # set to None if analysis_output (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_output is None and "analysis_output" in self.model_fields_set:
            _dict['analysisOutput'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateCwlWithJsonInputAnalysis from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "userReference": obj.get("userReference"),
            "pipelineId": obj.get("pipelineId"),
            "tags": CreateAnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "analysisStorageId": obj.get("analysisStorageId"),
            "outputParentFolderId": obj.get("outputParentFolderId"),
            "analysisOutput": [AnalysisOutputMapping.from_dict(_item) for _item in obj["analysisOutput"]] if obj.get("analysisOutput") is not None else None,
            "analysisInput": CwlAnalysisWithJsonInput.from_dict(obj["analysisInput"]) if obj.get("analysisInput") is not None else None
        })
        return _obj

CreateCwlWithJsonInputAnalysis

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_input : CwlAnalysisWithJsonInput

The type of the None singleton.

var analysis_output : List[AnalysisOutputMapping | None] | None

The type of the None singleton.

var analysis_storage_id : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var output_parent_folder_id : str | None

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var tags : CreateAnalysisTag | None

The type of the None singleton.

var user_reference : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateCwlWithJsonInputAnalysis from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateCwlWithJsonInputAnalysis from a JSON string

def user_reference_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
    _items = []
    if self.analysis_output:
        for _item_analysis_output in self.analysis_output:
            if _item_analysis_output:
                _items.append(_item_analysis_output.to_dict())
        _dict['analysisOutput'] = _items
    # override the default output from pydantic by calling `to_dict()` of analysis_input
    if self.analysis_input:
        _dict['analysisInput'] = self.analysis_input.to_dict()
    # set to None if analysis_storage_id (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
        _dict['analysisStorageId'] = None

    # set to None if output_parent_folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
        _dict['outputParentFolderId'] = None

    # set to None if analysis_output (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_output is None and "analysis_output" in self.model_fields_set:
        _dict['analysisOutput'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateCwlWithStructuredInputAnalysis (**data: Any)

Expand source code

class CreateCwlWithStructuredInputAnalysis(BaseModel):
    """
    CreateCwlWithStructuredInputAnalysis
    """ # noqa: E501
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user-reference of the analysis. This should be something meaningful for the user.", alias="userReference")
    pipeline_id: StrictStr = Field(description="The pipeline for which an analysis will be created.", alias="pipelineId")
    tags: Optional[CreateAnalysisTag] = None
    analysis_storage_id: Optional[StrictStr] = Field(default=None, description="The id of the storage to use for the analysis.", alias="analysisStorageId")
    output_parent_folder_id: Optional[StrictStr] = Field(default=None, description="The id or the urn of the folder in which the output folder should be created.", alias="outputParentFolderId")
    analysis_output: Optional[List[Optional[AnalysisOutputMapping]]] = Field(default=None, alias="analysisOutput")
    analysis_input: CwlAnalysisWithStructuredInput = Field(alias="analysisInput")
    __properties: ClassVar[List[str]] = ["userReference", "pipelineId", "tags", "analysisStorageId", "outputParentFolderId", "analysisOutput", "analysisInput"]

    @field_validator('user_reference')
    def user_reference_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$", value):
            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateCwlWithStructuredInputAnalysis from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
        _items = []
        if self.analysis_output:
            for _item_analysis_output in self.analysis_output:
                if _item_analysis_output:
                    _items.append(_item_analysis_output.to_dict())
            _dict['analysisOutput'] = _items
        # override the default output from pydantic by calling `to_dict()` of analysis_input
        if self.analysis_input:
            _dict['analysisInput'] = self.analysis_input.to_dict()
        # set to None if analysis_storage_id (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
            _dict['analysisStorageId'] = None

        # set to None if output_parent_folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
            _dict['outputParentFolderId'] = None

        # set to None if analysis_output (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_output is None and "analysis_output" in self.model_fields_set:
            _dict['analysisOutput'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateCwlWithStructuredInputAnalysis from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "userReference": obj.get("userReference"),
            "pipelineId": obj.get("pipelineId"),
            "tags": CreateAnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "analysisStorageId": obj.get("analysisStorageId"),
            "outputParentFolderId": obj.get("outputParentFolderId"),
            "analysisOutput": [AnalysisOutputMapping.from_dict(_item) for _item in obj["analysisOutput"]] if obj.get("analysisOutput") is not None else None,
            "analysisInput": CwlAnalysisWithStructuredInput.from_dict(obj["analysisInput"]) if obj.get("analysisInput") is not None else None
        })
        return _obj

CreateCwlWithStructuredInputAnalysis

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_input : CwlAnalysisWithStructuredInput

The type of the None singleton.

var analysis_output : List[AnalysisOutputMapping | None] | None

The type of the None singleton.

var analysis_storage_id : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var output_parent_folder_id : str | None

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var tags : CreateAnalysisTag | None

The type of the None singleton.

var user_reference : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateCwlWithStructuredInputAnalysis from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateCwlWithStructuredInputAnalysis from a JSON string

def user_reference_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
    _items = []
    if self.analysis_output:
        for _item_analysis_output in self.analysis_output:
            if _item_analysis_output:
                _items.append(_item_analysis_output.to_dict())
        _dict['analysisOutput'] = _items
    # override the default output from pydantic by calling `to_dict()` of analysis_input
    if self.analysis_input:
        _dict['analysisInput'] = self.analysis_input.to_dict()
    # set to None if analysis_storage_id (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
        _dict['analysisStorageId'] = None

    # set to None if output_parent_folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
        _dict['outputParentFolderId'] = None

    # set to None if analysis_output (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_output is None and "analysis_output" in self.model_fields_set:
        _dict['analysisOutput'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateData (**data: Any)

Expand source code

class CreateData(BaseModel):
    """
    CreateData
    """ # noqa: E501
    name: StrictStr = Field(description="The name of the file/folder as how it will be created.")
    folder_id: Optional[StrictStr] = Field(default=None, description="The id of the folder you want to create this new data in. Alternatively, the folderPath attribute could be used as well for this.", alias="folderId")
    folder_path: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The absolute path of the folder you want to create this new data in which must end with '/'. Alternatively, the folderId attribute could be used as well for this. In case the folder path does not yet exist, it will be automatically created.", alias="folderPath")
    format_code: Optional[StrictStr] = Field(default=None, description="The code of the format you would like to assign at creation time. This is only allowed for file data. If not specified, auto format assignment will be done.", alias="formatCode")
    data_type: StrictStr = Field(alias="dataType")
    __properties: ClassVar[List[str]] = ["name", "folderId", "folderPath", "formatCode", "dataType"]

    @field_validator('folder_path')
    def folder_path_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if value is None:
            return value

        if not re.match(r".*\/$", value):
            raise ValueError(r"must validate the regular expression /.*\/$/")
        return value

    @field_validator('data_type')
    def data_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['FILE', 'FOLDER']):
            raise ValueError("must be one of enum values ('FILE', 'FOLDER')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.folder_id is None and "folder_id" in self.model_fields_set:
            _dict['folderId'] = None

        # set to None if folder_path (nullable) is None
        # and model_fields_set contains the field
        if self.folder_path is None and "folder_path" in self.model_fields_set:
            _dict['folderPath'] = None

        # set to None if format_code (nullable) is None
        # and model_fields_set contains the field
        if self.format_code is None and "format_code" in self.model_fields_set:
            _dict['formatCode'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "folderId": obj.get("folderId"),
            "folderPath": obj.get("folderPath"),
            "formatCode": obj.get("formatCode"),
            "dataType": obj.get("dataType")
        })
        return _obj

CreateData

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_type : str

The type of the None singleton.

var folder_id : str | None

The type of the None singleton.

var folder_path : str | None

The type of the None singleton.

var format_code : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def data_type_validate_enum(value)

Validates the enum

def folder_path_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.folder_id is None and "folder_id" in self.model_fields_set:
        _dict['folderId'] = None

    # set to None if folder_path (nullable) is None
    # and model_fields_set contains the field
    if self.folder_path is None and "folder_path" in self.model_fields_set:
        _dict['folderPath'] = None

    # set to None if format_code (nullable) is None
    # and model_fields_set contains the field
    if self.format_code is None and "format_code" in self.model_fields_set:
        _dict['formatCode'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateDownloadRule (**data: Any)

Expand source code

class CreateDownloadRule(BaseModel):
    """
    CreateDownloadRule
    """ # noqa: E501
    code: StrictStr
    active: Optional[StrictBool] = None
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = None
    sequence: Annotated[int, Field(strict=True, ge=0)] = Field(description="Defines the order of the rule.")
    format_code: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="Regular expression to filter which format this rule applies to.", alias="formatCode")
    project_name: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="Regular expression to filter which project this rule applies to.", alias="projectName")
    target_local_folder: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The local folder where to write the data.", alias="targetLocalFolder")
    file_name_expression: Optional[StrictStr] = Field(default=None, description="Will allow the filename to be modified including a set of variables", alias="fileNameExpression")
    __properties: ClassVar[List[str]] = ["code", "active", "description", "sequence", "formatCode", "projectName", "targetLocalFolder", "fileNameExpression"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateDownloadRule from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if active (nullable) is None
        # and model_fields_set contains the field
        if self.active is None and "active" in self.model_fields_set:
            _dict['active'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if format_code (nullable) is None
        # and model_fields_set contains the field
        if self.format_code is None and "format_code" in self.model_fields_set:
            _dict['formatCode'] = None

        # set to None if project_name (nullable) is None
        # and model_fields_set contains the field
        if self.project_name is None and "project_name" in self.model_fields_set:
            _dict['projectName'] = None

        # set to None if file_name_expression (nullable) is None
        # and model_fields_set contains the field
        if self.file_name_expression is None and "file_name_expression" in self.model_fields_set:
            _dict['fileNameExpression'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateDownloadRule from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "active": obj.get("active"),
            "description": obj.get("description"),
            "sequence": obj.get("sequence"),
            "formatCode": obj.get("formatCode"),
            "projectName": obj.get("projectName"),
            "targetLocalFolder": obj.get("targetLocalFolder"),
            "fileNameExpression": obj.get("fileNameExpression")
        })
        return _obj

CreateDownloadRule

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var active : bool | None

The type of the None singleton.

var code : str

The type of the None singleton.

var description : str | None

The type of the None singleton.

var file_name_expression : str | None

The type of the None singleton.

var format_code : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var project_name : str | None

The type of the None singleton.

var sequence : int

The type of the None singleton.

var target_local_folder : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateDownloadRule from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateDownloadRule from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if active (nullable) is None
    # and model_fields_set contains the field
    if self.active is None and "active" in self.model_fields_set:
        _dict['active'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if format_code (nullable) is None
    # and model_fields_set contains the field
    if self.format_code is None and "format_code" in self.model_fields_set:
        _dict['formatCode'] = None

    # set to None if project_name (nullable) is None
    # and model_fields_set contains the field
    if self.project_name is None and "project_name" in self.model_fields_set:
        _dict['projectName'] = None

    # set to None if file_name_expression (nullable) is None
    # and model_fields_set contains the field
    if self.file_name_expression is None and "file_name_expression" in self.model_fields_set:
        _dict['fileNameExpression'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateExternalDockerImage (**data: Any)

Expand source code

class CreateExternalDockerImage(BaseModel):
    """
    CreateExternalDockerImage
    """ # noqa: E501
    url: StrictStr
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    version: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = None
    type: StrictStr
    __properties: ClassVar[List[str]] = ["url", "name", "version", "description", "type"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['TOOL', 'BENCH']):
            raise ValueError("must be one of enum values ('TOOL', 'BENCH')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateExternalDockerImage from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateExternalDockerImage from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "url": obj.get("url"),
            "name": obj.get("name"),
            "version": obj.get("version"),
            "description": obj.get("description"),
            "type": obj.get("type")
        })
        return _obj

CreateExternalDockerImage

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var type : str

The type of the None singleton.

var url : str

The type of the None singleton.

var version : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateExternalDockerImage from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateExternalDockerImage from a JSON string

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateFileAndTemporaryCredentials (**data: Any)

Expand source code

class CreateFileAndTemporaryCredentials(BaseModel):
    """
    CreateFileAndTemporaryCredentials
    """ # noqa: E501
    name: StrictStr = Field(description="The name of the file as how it will be created.")
    folder_id: Optional[StrictStr] = Field(default=None, description="The id of the folder you want to create this new file in. Alternatively, the folderPath attribute could be used as well for this.", alias="folderId")
    folder_path: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The absolute path of the folder you want to create this new file in which must end with '/'. Alternatively, the folderId attribute could be used as well for this. In case the folder path does not yet exist, it will be automatically created.", alias="folderPath")
    format_code: Optional[StrictStr] = Field(default=None, description="The code of the format you would like to assign at creation time. If not specified, auto format assignment will be done.", alias="formatCode")
    temporary_credentials: Optional[CreateTemporaryCredentials] = Field(default=None, alias="temporaryCredentials")
    __properties: ClassVar[List[str]] = ["name", "folderId", "folderPath", "formatCode", "temporaryCredentials"]

    @field_validator('folder_path')
    def folder_path_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if value is None:
            return value

        if not re.match(r".*\/$", value):
            raise ValueError(r"must validate the regular expression /.*\/$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateFileAndTemporaryCredentials from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of temporary_credentials
        if self.temporary_credentials:
            _dict['temporaryCredentials'] = self.temporary_credentials.to_dict()
        # set to None if folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.folder_id is None and "folder_id" in self.model_fields_set:
            _dict['folderId'] = None

        # set to None if folder_path (nullable) is None
        # and model_fields_set contains the field
        if self.folder_path is None and "folder_path" in self.model_fields_set:
            _dict['folderPath'] = None

        # set to None if format_code (nullable) is None
        # and model_fields_set contains the field
        if self.format_code is None and "format_code" in self.model_fields_set:
            _dict['formatCode'] = None

        # set to None if temporary_credentials (nullable) is None
        # and model_fields_set contains the field
        if self.temporary_credentials is None and "temporary_credentials" in self.model_fields_set:
            _dict['temporaryCredentials'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateFileAndTemporaryCredentials from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "folderId": obj.get("folderId"),
            "folderPath": obj.get("folderPath"),
            "formatCode": obj.get("formatCode"),
            "temporaryCredentials": CreateTemporaryCredentials.from_dict(obj["temporaryCredentials"]) if obj.get("temporaryCredentials") is not None else None
        })
        return _obj

CreateFileAndTemporaryCredentials

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var folder_id : str | None

The type of the None singleton.

var folder_path : str | None

The type of the None singleton.

var format_code : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var temporary_credentials : CreateTemporaryCredentials | None

The type of the None singleton.

Static methods

def folder_path_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateFileAndTemporaryCredentials from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateFileAndTemporaryCredentials from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of temporary_credentials
    if self.temporary_credentials:
        _dict['temporaryCredentials'] = self.temporary_credentials.to_dict()
    # set to None if folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.folder_id is None and "folder_id" in self.model_fields_set:
        _dict['folderId'] = None

    # set to None if folder_path (nullable) is None
    # and model_fields_set contains the field
    if self.folder_path is None and "folder_path" in self.model_fields_set:
        _dict['folderPath'] = None

    # set to None if format_code (nullable) is None
    # and model_fields_set contains the field
    if self.format_code is None and "format_code" in self.model_fields_set:
        _dict['formatCode'] = None

    # set to None if temporary_credentials (nullable) is None
    # and model_fields_set contains the field
    if self.temporary_credentials is None and "temporary_credentials" in self.model_fields_set:
        _dict['temporaryCredentials'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateFileAndUploadUrl (**data: Any)

Expand source code

class CreateFileAndUploadUrl(BaseModel):
    """
    CreateFileAndUploadUrl
    """ # noqa: E501
    name: StrictStr = Field(description="The name of the file as how it will be created.")
    folder_id: Optional[StrictStr] = Field(default=None, description="The id of the folder you want to create this new file in. Alternatively, the folderPath attribute could be used as well for this.", alias="folderId")
    folder_path: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The absolute path of the folder you want to create this new file in which must end with '/'. Alternatively, the folderId attribute could be used as well for this. In case the folder path does not yet exist, it will be automatically created.", alias="folderPath")
    format_code: Optional[StrictStr] = Field(default=None, description="The code of the format you would like to assign at creation time. If not specified, auto format assignment will be done.", alias="formatCode")
    file_type: Optional[StrictStr] = Field(default=None, description="The expected content type for the upload, to include in the upload url.", alias="fileType")
    hash: Optional[StrictStr] = Field(default=None, description="The expected md5 hash for the upload content, to include in the upload url.")
    __properties: ClassVar[List[str]] = ["name", "folderId", "folderPath", "formatCode", "fileType", "hash"]

    @field_validator('folder_path')
    def folder_path_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if value is None:
            return value

        if not re.match(r".*\/$", value):
            raise ValueError(r"must validate the regular expression /.*\/$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateFileAndUploadUrl from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.folder_id is None and "folder_id" in self.model_fields_set:
            _dict['folderId'] = None

        # set to None if folder_path (nullable) is None
        # and model_fields_set contains the field
        if self.folder_path is None and "folder_path" in self.model_fields_set:
            _dict['folderPath'] = None

        # set to None if format_code (nullable) is None
        # and model_fields_set contains the field
        if self.format_code is None and "format_code" in self.model_fields_set:
            _dict['formatCode'] = None

        # set to None if file_type (nullable) is None
        # and model_fields_set contains the field
        if self.file_type is None and "file_type" in self.model_fields_set:
            _dict['fileType'] = None

        # set to None if hash (nullable) is None
        # and model_fields_set contains the field
        if self.hash is None and "hash" in self.model_fields_set:
            _dict['hash'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateFileAndUploadUrl from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "folderId": obj.get("folderId"),
            "folderPath": obj.get("folderPath"),
            "formatCode": obj.get("formatCode"),
            "fileType": obj.get("fileType"),
            "hash": obj.get("hash")
        })
        return _obj

CreateFileAndUploadUrl

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var file_type : str | None

The type of the None singleton.

var folder_id : str | None

The type of the None singleton.

var folder_path : str | None

The type of the None singleton.

var format_code : str | None

The type of the None singleton.

var hash : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def folder_path_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateFileAndUploadUrl from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateFileAndUploadUrl from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.folder_id is None and "folder_id" in self.model_fields_set:
        _dict['folderId'] = None

    # set to None if folder_path (nullable) is None
    # and model_fields_set contains the field
    if self.folder_path is None and "folder_path" in self.model_fields_set:
        _dict['folderPath'] = None

    # set to None if format_code (nullable) is None
    # and model_fields_set contains the field
    if self.format_code is None and "format_code" in self.model_fields_set:
        _dict['formatCode'] = None

    # set to None if file_type (nullable) is None
    # and model_fields_set contains the field
    if self.file_type is None and "file_type" in self.model_fields_set:
        _dict['fileType'] = None

    # set to None if hash (nullable) is None
    # and model_fields_set contains the field
    if self.hash is None and "hash" in self.model_fields_set:
        _dict['hash'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateFileData (**data: Any)

Expand source code

class CreateFileData(BaseModel):
    """
    CreateFileData
    """ # noqa: E501
    name: StrictStr = Field(description="The name of the file as how it will be created.")
    folder_id: Optional[StrictStr] = Field(default=None, description="The id of the folder you want to create this new file in. Alternatively, the folderPath attribute could be used as well for this.", alias="folderId")
    folder_path: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The absolute path of the folder you want to create this new file in which must end with '/'. Alternatively, the folderId attribute could be used as well for this. In case the folder path does not yet exist, it will be automatically created.", alias="folderPath")
    format_code: Optional[StrictStr] = Field(default=None, description="The code of the format you would like to assign at creation time. If not specified, auto format assignment will be done.", alias="formatCode")
    __properties: ClassVar[List[str]] = ["name", "folderId", "folderPath", "formatCode"]

    @field_validator('folder_path')
    def folder_path_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if value is None:
            return value

        if not re.match(r".*\/$", value):
            raise ValueError(r"must validate the regular expression /.*\/$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateFileData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.folder_id is None and "folder_id" in self.model_fields_set:
            _dict['folderId'] = None

        # set to None if folder_path (nullable) is None
        # and model_fields_set contains the field
        if self.folder_path is None and "folder_path" in self.model_fields_set:
            _dict['folderPath'] = None

        # set to None if format_code (nullable) is None
        # and model_fields_set contains the field
        if self.format_code is None and "format_code" in self.model_fields_set:
            _dict['formatCode'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateFileData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "folderId": obj.get("folderId"),
            "folderPath": obj.get("folderPath"),
            "formatCode": obj.get("formatCode")
        })
        return _obj

CreateFileData

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var folder_id : str | None

The type of the None singleton.

var folder_path : str | None

The type of the None singleton.

var format_code : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def folder_path_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateFileData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateFileData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.folder_id is None and "folder_id" in self.model_fields_set:
        _dict['folderId'] = None

    # set to None if folder_path (nullable) is None
    # and model_fields_set contains the field
    if self.folder_path is None and "folder_path" in self.model_fields_set:
        _dict['folderPath'] = None

    # set to None if format_code (nullable) is None
    # and model_fields_set contains the field
    if self.format_code is None and "format_code" in self.model_fields_set:
        _dict['formatCode'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateFolder (**data: Any)

Expand source code

class CreateFolder(BaseModel):
    """
    CreateFolder
    """ # noqa: E501
    name: StrictStr = Field(description="The name of the folder as how it will be created.")
    folder_id: Optional[StrictStr] = Field(default=None, description="The id of the folder you want to create this new folder in. Alternatively, the folderPath attribute could be used as well for this.", alias="folderId")
    folder_path: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The absolute path of the folder you want to create this new folder in which must end with '/'. Alternatively, the folderId attribute could be used as well for this. In case the folder path does not yet exist, it will be automatically created.", alias="folderPath")
    __properties: ClassVar[List[str]] = ["name", "folderId", "folderPath"]

    @field_validator('folder_path')
    def folder_path_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if value is None:
            return value

        if not re.match(r".*\/$", value):
            raise ValueError(r"must validate the regular expression /.*\/$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateFolder from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.folder_id is None and "folder_id" in self.model_fields_set:
            _dict['folderId'] = None

        # set to None if folder_path (nullable) is None
        # and model_fields_set contains the field
        if self.folder_path is None and "folder_path" in self.model_fields_set:
            _dict['folderPath'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateFolder from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "folderId": obj.get("folderId"),
            "folderPath": obj.get("folderPath")
        })
        return _obj

CreateFolder

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var folder_id : str | None

The type of the None singleton.

var folder_path : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def folder_path_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateFolder from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateFolder from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.folder_id is None and "folder_id" in self.model_fields_set:
        _dict['folderId'] = None

    # set to None if folder_path (nullable) is None
    # and model_fields_set contains the field
    if self.folder_path is None and "folder_path" in self.model_fields_set:
        _dict['folderPath'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateFolderAndTemporaryCredentials (**data: Any)

Expand source code

class CreateFolderAndTemporaryCredentials(BaseModel):
    """
    CreateFolderAndTemporaryCredentials
    """ # noqa: E501
    name: StrictStr = Field(description="The name of the folder as how it will be created.")
    folder_id: Optional[StrictStr] = Field(default=None, description="The id of the folder you want to create this new folder in. Alternatively, the folderPath attribute could be used as well for this.", alias="folderId")
    folder_path: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The absolute path of the folder you want to create this new folder in which must end with '/'. Alternatively, the folderId attribute could be used as well for this. In case the folder path does not yet exist, it will be automatically created.", alias="folderPath")
    non_indexed: Optional[StrictBool] = Field(default=False, description="If you want to create a non-indexed folder. Only possible as a top-level folder, which means the folderId and folderPath attributes are not allowed.", alias="nonIndexed")
    temporary_credentials: Optional[CreateTemporaryCredentials] = Field(default=None, alias="temporaryCredentials")
    __properties: ClassVar[List[str]] = ["name", "folderId", "folderPath", "nonIndexed", "temporaryCredentials"]

    @field_validator('folder_path')
    def folder_path_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if value is None:
            return value

        if not re.match(r".*\/$", value):
            raise ValueError(r"must validate the regular expression /.*\/$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateFolderAndTemporaryCredentials from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of temporary_credentials
        if self.temporary_credentials:
            _dict['temporaryCredentials'] = self.temporary_credentials.to_dict()
        # set to None if folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.folder_id is None and "folder_id" in self.model_fields_set:
            _dict['folderId'] = None

        # set to None if folder_path (nullable) is None
        # and model_fields_set contains the field
        if self.folder_path is None and "folder_path" in self.model_fields_set:
            _dict['folderPath'] = None

        # set to None if non_indexed (nullable) is None
        # and model_fields_set contains the field
        if self.non_indexed is None and "non_indexed" in self.model_fields_set:
            _dict['nonIndexed'] = None

        # set to None if temporary_credentials (nullable) is None
        # and model_fields_set contains the field
        if self.temporary_credentials is None and "temporary_credentials" in self.model_fields_set:
            _dict['temporaryCredentials'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateFolderAndTemporaryCredentials from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "folderId": obj.get("folderId"),
            "folderPath": obj.get("folderPath"),
            "nonIndexed": obj.get("nonIndexed") if obj.get("nonIndexed") is not None else False,
            "temporaryCredentials": CreateTemporaryCredentials.from_dict(obj["temporaryCredentials"]) if obj.get("temporaryCredentials") is not None else None
        })
        return _obj

CreateFolderAndTemporaryCredentials

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var folder_id : str | None

The type of the None singleton.

var folder_path : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var non_indexed : bool | None

The type of the None singleton.

var temporary_credentials : CreateTemporaryCredentials | None

The type of the None singleton.

Static methods

def folder_path_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateFolderAndTemporaryCredentials from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateFolderAndTemporaryCredentials from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of temporary_credentials
    if self.temporary_credentials:
        _dict['temporaryCredentials'] = self.temporary_credentials.to_dict()
    # set to None if folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.folder_id is None and "folder_id" in self.model_fields_set:
        _dict['folderId'] = None

    # set to None if folder_path (nullable) is None
    # and model_fields_set contains the field
    if self.folder_path is None and "folder_path" in self.model_fields_set:
        _dict['folderPath'] = None

    # set to None if non_indexed (nullable) is None
    # and model_fields_set contains the field
    if self.non_indexed is None and "non_indexed" in self.model_fields_set:
        _dict['nonIndexed'] = None

    # set to None if temporary_credentials (nullable) is None
    # and model_fields_set contains the field
    if self.temporary_credentials is None and "temporary_credentials" in self.model_fields_set:
        _dict['temporaryCredentials'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateInternalDockerImage (**data: Any)

Expand source code

class CreateInternalDockerImage(BaseModel):
    """
    CreateInternalDockerImage
    """ # noqa: E501
    docker_data_id: StrictStr = Field(description="The id of the data for which an Docker image will be created.", alias="dockerDataId")
    docker_data_project_id: StrictStr = Field(description="The id of the project where the Docker data resides.", alias="dockerDataProjectId")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    version: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = None
    type: StrictStr
    regions: List[StrictStr] = Field(description="The UUID of the regions where the Docker image will be made available.")
    __properties: ClassVar[List[str]] = ["dockerDataId", "dockerDataProjectId", "name", "version", "description", "type", "regions"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['TOOL', 'BENCH']):
            raise ValueError("must be one of enum values ('TOOL', 'BENCH')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateInternalDockerImage from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateInternalDockerImage from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dockerDataId": obj.get("dockerDataId"),
            "dockerDataProjectId": obj.get("dockerDataProjectId"),
            "name": obj.get("name"),
            "version": obj.get("version"),
            "description": obj.get("description"),
            "type": obj.get("type"),
            "regions": obj.get("regions")
        })
        return _obj

CreateInternalDockerImage

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var docker_data_id : str

The type of the None singleton.

var docker_data_project_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var regions : List[str]

The type of the None singleton.

var type : str

The type of the None singleton.

var version : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateInternalDockerImage from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateInternalDockerImage from a JSON string

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateNextflowAnalysis (**data: Any)

Expand source code

class CreateNextflowAnalysis(BaseModel):
    """
    CreateNextflowAnalysis
    """ # noqa: E501
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user-reference of the analysis. This should be something meaningful for the user.", alias="userReference")
    pipeline_id: StrictStr = Field(description="The pipeline for which an analysis will be created.", alias="pipelineId")
    tags: Optional[CreateAnalysisTag] = None
    analysis_storage_id: Optional[StrictStr] = Field(default=None, description="The id of the storage to use for the analysis.", alias="analysisStorageId")
    output_parent_folder_id: Optional[StrictStr] = Field(default=None, description="The id or the urn of the folder in which the output folder should be created.", alias="outputParentFolderId")
    analysis_output: Optional[List[Optional[AnalysisOutputMapping]]] = Field(default=None, alias="analysisOutput")
    analysis_input: NextflowAnalysisInput = Field(alias="analysisInput")
    activation_code_detail_id: Optional[StrictStr] = Field(default=None, description="Indicates under which activation code the pipeline is executed.", alias="activationCodeDetailId")
    __properties: ClassVar[List[str]] = ["userReference", "pipelineId", "tags", "analysisStorageId", "outputParentFolderId", "analysisOutput", "analysisInput", "activationCodeDetailId"]

    @field_validator('user_reference')
    def user_reference_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$", value):
            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateNextflowAnalysis from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
        _items = []
        if self.analysis_output:
            for _item_analysis_output in self.analysis_output:
                if _item_analysis_output:
                    _items.append(_item_analysis_output.to_dict())
            _dict['analysisOutput'] = _items
        # override the default output from pydantic by calling `to_dict()` of analysis_input
        if self.analysis_input:
            _dict['analysisInput'] = self.analysis_input.to_dict()
        # set to None if analysis_storage_id (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
            _dict['analysisStorageId'] = None

        # set to None if output_parent_folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
            _dict['outputParentFolderId'] = None

        # set to None if analysis_output (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_output is None and "analysis_output" in self.model_fields_set:
            _dict['analysisOutput'] = None

        # set to None if activation_code_detail_id (nullable) is None
        # and model_fields_set contains the field
        if self.activation_code_detail_id is None and "activation_code_detail_id" in self.model_fields_set:
            _dict['activationCodeDetailId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateNextflowAnalysis from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "userReference": obj.get("userReference"),
            "pipelineId": obj.get("pipelineId"),
            "tags": CreateAnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "analysisStorageId": obj.get("analysisStorageId"),
            "outputParentFolderId": obj.get("outputParentFolderId"),
            "analysisOutput": [AnalysisOutputMapping.from_dict(_item) for _item in obj["analysisOutput"]] if obj.get("analysisOutput") is not None else None,
            "analysisInput": NextflowAnalysisInput.from_dict(obj["analysisInput"]) if obj.get("analysisInput") is not None else None,
            "activationCodeDetailId": obj.get("activationCodeDetailId")
        })
        return _obj

CreateNextflowAnalysis

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var activation_code_detail_id : str | None

The type of the None singleton.

var analysis_input : NextflowAnalysisInput

The type of the None singleton.

var analysis_output : List[AnalysisOutputMapping | None] | None

The type of the None singleton.

var analysis_storage_id : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var output_parent_folder_id : str | None

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var tags : CreateAnalysisTag | None

The type of the None singleton.

var user_reference : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateNextflowAnalysis from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateNextflowAnalysis from a JSON string

def user_reference_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
    _items = []
    if self.analysis_output:
        for _item_analysis_output in self.analysis_output:
            if _item_analysis_output:
                _items.append(_item_analysis_output.to_dict())
        _dict['analysisOutput'] = _items
    # override the default output from pydantic by calling `to_dict()` of analysis_input
    if self.analysis_input:
        _dict['analysisInput'] = self.analysis_input.to_dict()
    # set to None if analysis_storage_id (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
        _dict['analysisStorageId'] = None

    # set to None if output_parent_folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
        _dict['outputParentFolderId'] = None

    # set to None if analysis_output (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_output is None and "analysis_output" in self.model_fields_set:
        _dict['analysisOutput'] = None

    # set to None if activation_code_detail_id (nullable) is None
    # and model_fields_set contains the field
    if self.activation_code_detail_id is None and "activation_code_detail_id" in self.model_fields_set:
        _dict['activationCodeDetailId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateNextflowJsonAnalysis (**data: Any)

Expand source code

class CreateNextflowJsonAnalysis(BaseModel):
    """
    CreateNextflowJsonAnalysis
    """ # noqa: E501
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user-reference of the analysis. This should be something meaningful for the user.", alias="userReference")
    pipeline_id: StrictStr = Field(description="The pipeline for which an analysis will be created.", alias="pipelineId")
    tags: Optional[CreateAnalysisTag] = None
    analysis_storage_id: Optional[StrictStr] = Field(default=None, description="The id of the storage to use for the analysis.", alias="analysisStorageId")
    output_parent_folder_id: Optional[StrictStr] = Field(default=None, description="The id or the urn of the folder in which the output folder should be created.", alias="outputParentFolderId")
    analysis_output: Optional[List[Optional[AnalysisOutputMapping]]] = Field(default=None, alias="analysisOutput")
    input_form_values: NextflowJsonAnalysisInput = Field(alias="inputFormValues")
    __properties: ClassVar[List[str]] = ["userReference", "pipelineId", "tags", "analysisStorageId", "outputParentFolderId", "analysisOutput", "inputFormValues"]

    @field_validator('user_reference')
    def user_reference_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$", value):
            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateNextflowJsonAnalysis from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
        _items = []
        if self.analysis_output:
            for _item_analysis_output in self.analysis_output:
                if _item_analysis_output:
                    _items.append(_item_analysis_output.to_dict())
            _dict['analysisOutput'] = _items
        # override the default output from pydantic by calling `to_dict()` of input_form_values
        if self.input_form_values:
            _dict['inputFormValues'] = self.input_form_values.to_dict()
        # set to None if analysis_storage_id (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
            _dict['analysisStorageId'] = None

        # set to None if output_parent_folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
            _dict['outputParentFolderId'] = None

        # set to None if analysis_output (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_output is None and "analysis_output" in self.model_fields_set:
            _dict['analysisOutput'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateNextflowJsonAnalysis from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "userReference": obj.get("userReference"),
            "pipelineId": obj.get("pipelineId"),
            "tags": CreateAnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "analysisStorageId": obj.get("analysisStorageId"),
            "outputParentFolderId": obj.get("outputParentFolderId"),
            "analysisOutput": [AnalysisOutputMapping.from_dict(_item) for _item in obj["analysisOutput"]] if obj.get("analysisOutput") is not None else None,
            "inputFormValues": NextflowJsonAnalysisInput.from_dict(obj["inputFormValues"]) if obj.get("inputFormValues") is not None else None
        })
        return _obj

CreateNextflowJsonAnalysis

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_output : List[AnalysisOutputMapping | None] | None

The type of the None singleton.

var analysis_storage_id : str | None

The type of the None singleton.

var input_form_values : NextflowJsonAnalysisInput

The type of the None singleton.

var model_config

The type of the None singleton.

var output_parent_folder_id : str | None

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var tags : CreateAnalysisTag | None

The type of the None singleton.

var user_reference : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateNextflowJsonAnalysis from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateNextflowJsonAnalysis from a JSON string

def user_reference_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
    _items = []
    if self.analysis_output:
        for _item_analysis_output in self.analysis_output:
            if _item_analysis_output:
                _items.append(_item_analysis_output.to_dict())
        _dict['analysisOutput'] = _items
    # override the default output from pydantic by calling `to_dict()` of input_form_values
    if self.input_form_values:
        _dict['inputFormValues'] = self.input_form_values.to_dict()
    # set to None if analysis_storage_id (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
        _dict['analysisStorageId'] = None

    # set to None if output_parent_folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
        _dict['outputParentFolderId'] = None

    # set to None if analysis_output (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_output is None and "analysis_output" in self.model_fields_set:
        _dict['analysisOutput'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateNextflowWithCustomInputAnalysis (**data: Any)

Expand source code

class CreateNextflowWithCustomInputAnalysis(BaseModel):
    """
    CreateNextflowWithCustomInputAnalysis
    """ # noqa: E501
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user-reference of the analysis. This should be something meaningful for the user.", alias="userReference")
    pipeline_id: StrictStr = Field(description="The pipeline for which an analysis will be created.", alias="pipelineId")
    tags: Optional[CreateAnalysisTag] = None
    analysis_storage_id: Optional[StrictStr] = Field(default=None, description="The id of the storage to use for the analysis.", alias="analysisStorageId")
    output_parent_folder_id: Optional[StrictStr] = Field(default=None, description="The id or the urn of the folder in which the output folder should be created.", alias="outputParentFolderId")
    analysis_output: Optional[List[Optional[AnalysisOutputMapping]]] = Field(default=None, alias="analysisOutput")
    analysis_input: NextflowAnalysisWithCustomInput = Field(alias="analysisInput")
    __properties: ClassVar[List[str]] = ["userReference", "pipelineId", "tags", "analysisStorageId", "outputParentFolderId", "analysisOutput", "analysisInput"]

    @field_validator('user_reference')
    def user_reference_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$", value):
            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9 _-]*(\/[a-zA-Z0-9 _-]+)*$/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateNextflowWithCustomInputAnalysis from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
        _items = []
        if self.analysis_output:
            for _item_analysis_output in self.analysis_output:
                if _item_analysis_output:
                    _items.append(_item_analysis_output.to_dict())
            _dict['analysisOutput'] = _items
        # override the default output from pydantic by calling `to_dict()` of analysis_input
        if self.analysis_input:
            _dict['analysisInput'] = self.analysis_input.to_dict()
        # set to None if analysis_storage_id (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
            _dict['analysisStorageId'] = None

        # set to None if output_parent_folder_id (nullable) is None
        # and model_fields_set contains the field
        if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
            _dict['outputParentFolderId'] = None

        # set to None if analysis_output (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_output is None and "analysis_output" in self.model_fields_set:
            _dict['analysisOutput'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateNextflowWithCustomInputAnalysis from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "userReference": obj.get("userReference"),
            "pipelineId": obj.get("pipelineId"),
            "tags": CreateAnalysisTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "analysisStorageId": obj.get("analysisStorageId"),
            "outputParentFolderId": obj.get("outputParentFolderId"),
            "analysisOutput": [AnalysisOutputMapping.from_dict(_item) for _item in obj["analysisOutput"]] if obj.get("analysisOutput") is not None else None,
            "analysisInput": NextflowAnalysisWithCustomInput.from_dict(obj["analysisInput"]) if obj.get("analysisInput") is not None else None
        })
        return _obj

CreateNextflowWithCustomInputAnalysis

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_input : NextflowAnalysisWithCustomInput

The type of the None singleton.

var analysis_output : List[AnalysisOutputMapping | None] | None

The type of the None singleton.

var analysis_storage_id : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var output_parent_folder_id : str | None

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var tags : CreateAnalysisTag | None

The type of the None singleton.

var user_reference : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateNextflowWithCustomInputAnalysis from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateNextflowWithCustomInputAnalysis from a JSON string

def user_reference_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_output (list)
    _items = []
    if self.analysis_output:
        for _item_analysis_output in self.analysis_output:
            if _item_analysis_output:
                _items.append(_item_analysis_output.to_dict())
        _dict['analysisOutput'] = _items
    # override the default output from pydantic by calling `to_dict()` of analysis_input
    if self.analysis_input:
        _dict['analysisInput'] = self.analysis_input.to_dict()
    # set to None if analysis_storage_id (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_storage_id is None and "analysis_storage_id" in self.model_fields_set:
        _dict['analysisStorageId'] = None

    # set to None if output_parent_folder_id (nullable) is None
    # and model_fields_set contains the field
    if self.output_parent_folder_id is None and "output_parent_folder_id" in self.model_fields_set:
        _dict['outputParentFolderId'] = None

    # set to None if analysis_output (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_output is None and "analysis_output" in self.model_fields_set:
        _dict['analysisOutput'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateNonIndexedFolder (**data: Any)

Expand source code

class CreateNonIndexedFolder(BaseModel):
    """
    CreateNonIndexedFolder
    """ # noqa: E501
    name: StrictStr = Field(description="The name of the non indexed folder.")
    __properties: ClassVar[List[str]] = ["name"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateNonIndexedFolder from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateNonIndexedFolder from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name")
        })
        return _obj

CreateNonIndexedFolder

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateNonIndexedFolder from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateNonIndexedFolder from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateNotificationChannel (**data: Any)

Expand source code

class CreateNotificationChannel(BaseModel):
    """
    CreateNotificationChannel
    """ # noqa: E501
    enabled: StrictBool = Field(description="Should this channel be enabled or not?")
    type: StrictStr = Field(description="The type of delivery target (MAIL, SQS, SNS, HTTP, ...)")
    address: Annotated[str, Field(min_length=1, strict=True, max_length=100)] = Field(description="The address where to send a notification to (email address, url, ...)")
    aws_region: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="The AWS region of the SNS notification channel", alias="awsRegion")
    __properties: ClassVar[List[str]] = ["enabled", "type", "address", "awsRegion"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['MAIL', 'SQS', 'SNS', 'HTTP']):
            raise ValueError("must be one of enum values ('MAIL', 'SQS', 'SNS', 'HTTP')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateNotificationChannel from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if aws_region (nullable) is None
        # and model_fields_set contains the field
        if self.aws_region is None and "aws_region" in self.model_fields_set:
            _dict['awsRegion'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateNotificationChannel from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "enabled": obj.get("enabled"),
            "type": obj.get("type"),
            "address": obj.get("address"),
            "awsRegion": obj.get("awsRegion")
        })
        return _obj

CreateNotificationChannel

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var address : str

The type of the None singleton.

var aws_region : str | None

The type of the None singleton.

var enabled : bool

The type of the None singleton.

var model_config

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateNotificationChannel from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateNotificationChannel from a JSON string

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if aws_region (nullable) is None
    # and model_fields_set contains the field
    if self.aws_region is None and "aws_region" in self.model_fields_set:
        _dict['awsRegion'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateNotificationSubscription (**data: Any)

Expand source code

class CreateNotificationSubscription(BaseModel):
    """
    CreateNotificationSubscription
    """ # noqa: E501
    event_code: Annotated[str, Field(min_length=1, strict=True, max_length=20)] = Field(description="The event code to subscribe to", alias="eventCode")
    payload_version: Optional[StrictStr] = Field(default=None, description="The version of the notification event payload in case multiple versions exist. For analysis events possible values are [V3,V4]", alias="payloadVersion")
    filter_expression: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=2000)]] = Field(default=None, description="To be used when a notification applies to specific conditions.", alias="filterExpression")
    enabled: StrictBool = Field(description="Should this subscription be enabled or not?")
    notification_channel_id: StrictStr = Field(description="The ID of the notification channel used to send on", alias="notificationChannelId")
    __properties: ClassVar[List[str]] = ["eventCode", "payloadVersion", "filterExpression", "enabled", "notificationChannelId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateNotificationSubscription from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if payload_version (nullable) is None
        # and model_fields_set contains the field
        if self.payload_version is None and "payload_version" in self.model_fields_set:
            _dict['payloadVersion'] = None

        # set to None if filter_expression (nullable) is None
        # and model_fields_set contains the field
        if self.filter_expression is None and "filter_expression" in self.model_fields_set:
            _dict['filterExpression'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateNotificationSubscription from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "eventCode": obj.get("eventCode"),
            "payloadVersion": obj.get("payloadVersion"),
            "filterExpression": obj.get("filterExpression"),
            "enabled": obj.get("enabled"),
            "notificationChannelId": obj.get("notificationChannelId")
        })
        return _obj

CreateNotificationSubscription

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var enabled : bool

The type of the None singleton.

var event_code : str

The type of the None singleton.

var filter_expression : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var notification_channel_id : str

The type of the None singleton.

var payload_version : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateNotificationSubscription from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateNotificationSubscription from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if payload_version (nullable) is None
    # and model_fields_set contains the field
    if self.payload_version is None and "payload_version" in self.model_fields_set:
        _dict['payloadVersion'] = None

    # set to None if filter_expression (nullable) is None
    # and model_fields_set contains the field
    if self.filter_expression is None and "filter_expression" in self.model_fields_set:
        _dict['filterExpression'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProject (**data: Any)

Expand source code

class CreateProject(BaseModel):
    """
    CreateProject
    """ # noqa: E501
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    short_description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = Field(default=None, alias="shortDescription")
    information: Optional[StrictStr] = Field(default=None, description="Information about the project. Note that the value of this field can be arbitrary large.")
    project_owner_id: Optional[StrictStr] = Field(default=None, description="Owner of the project. Defaults to the current user.", alias="projectOwnerId")
    region_id: StrictStr = Field(description="The region of the project. All data and pipeline executions will reside in this region.", alias="regionId")
    billing_mode: StrictStr = Field(description="The billing mode of the project. It determines who pays for the costs linked to the project.", alias="billingMode")
    data_sharing_enabled: StrictBool = Field(description="Indicates whether the Data and Samples created in this Project can be linked to other Projects.", alias="dataSharingEnabled")
    tags: Optional[ProjectTag] = None
    storage_bundle_id: StrictStr = Field(alias="storageBundleId")
    metadata_model_id: Optional[StrictStr] = Field(default=None, alias="metadataModelId")
    storage_configuration_id: Optional[StrictStr] = Field(default=None, description="An optional storage configuration id to have self managed storage.", alias="storageConfigurationId")
    storage_configuration_subfolder: Optional[StrictStr] = Field(default=None, description="An optional subfolder that determines the object prefix of your self managed storage.  If not used, you will not be able to use this storage configuration for any future projects.", alias="storageConfigurationSubfolder")
    analysis_priority: Optional[StrictStr] = Field(default='MEDIUM', description="Indicates the priority given to a project and its analyses within a single tenant, where MEDIUM is the default value.", alias="analysisPriority")
    __properties: ClassVar[List[str]] = ["name", "shortDescription", "information", "projectOwnerId", "regionId", "billingMode", "dataSharingEnabled", "tags", "storageBundleId", "metadataModelId", "storageConfigurationId", "storageConfigurationSubfolder", "analysisPriority"]

    @field_validator('name')
    def name_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"[a-zA-Z][a-zA-Z0-9_\s-]*", value):
            raise ValueError(r"must validate the regular expression /[a-zA-Z][a-zA-Z0-9_\s-]*/")
        return value

    @field_validator('billing_mode')
    def billing_mode_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['PROJECT', 'TENANT']):
            raise ValueError("must be one of enum values ('PROJECT', 'TENANT')")
        return value

    @field_validator('analysis_priority')
    def analysis_priority_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['LOW', 'MEDIUM', 'HIGH']):
            raise ValueError("must be one of enum values ('LOW', 'MEDIUM', 'HIGH')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProject from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # set to None if short_description (nullable) is None
        # and model_fields_set contains the field
        if self.short_description is None and "short_description" in self.model_fields_set:
            _dict['shortDescription'] = None

        # set to None if information (nullable) is None
        # and model_fields_set contains the field
        if self.information is None and "information" in self.model_fields_set:
            _dict['information'] = None

        # set to None if project_owner_id (nullable) is None
        # and model_fields_set contains the field
        if self.project_owner_id is None and "project_owner_id" in self.model_fields_set:
            _dict['projectOwnerId'] = None

        # set to None if metadata_model_id (nullable) is None
        # and model_fields_set contains the field
        if self.metadata_model_id is None and "metadata_model_id" in self.model_fields_set:
            _dict['metadataModelId'] = None

        # set to None if storage_configuration_id (nullable) is None
        # and model_fields_set contains the field
        if self.storage_configuration_id is None and "storage_configuration_id" in self.model_fields_set:
            _dict['storageConfigurationId'] = None

        # set to None if storage_configuration_subfolder (nullable) is None
        # and model_fields_set contains the field
        if self.storage_configuration_subfolder is None and "storage_configuration_subfolder" in self.model_fields_set:
            _dict['storageConfigurationSubfolder'] = None

        # set to None if analysis_priority (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_priority is None and "analysis_priority" in self.model_fields_set:
            _dict['analysisPriority'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProject from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "shortDescription": obj.get("shortDescription"),
            "information": obj.get("information"),
            "projectOwnerId": obj.get("projectOwnerId"),
            "regionId": obj.get("regionId"),
            "billingMode": obj.get("billingMode"),
            "dataSharingEnabled": obj.get("dataSharingEnabled"),
            "tags": ProjectTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "storageBundleId": obj.get("storageBundleId"),
            "metadataModelId": obj.get("metadataModelId"),
            "storageConfigurationId": obj.get("storageConfigurationId"),
            "storageConfigurationSubfolder": obj.get("storageConfigurationSubfolder"),
            "analysisPriority": obj.get("analysisPriority") if obj.get("analysisPriority") is not None else 'MEDIUM'
        })
        return _obj

CreateProject

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_priority : str | None

The type of the None singleton.

var billing_mode : str

The type of the None singleton.

var data_sharing_enabled : bool

The type of the None singleton.

var information : str | None

The type of the None singleton.

var metadata_model_id : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var project_owner_id : str | None

The type of the None singleton.

var region_id : str

The type of the None singleton.

var short_description : str | None

The type of the None singleton.

var storage_bundle_id : str

The type of the None singleton.

var storage_configuration_id : str | None

The type of the None singleton.

var storage_configuration_subfolder : str | None

The type of the None singleton.

var tags : ProjectTag | None

The type of the None singleton.

Static methods

def analysis_priority_validate_enum(value)

Validates the enum

def billing_mode_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProject from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProject from a JSON string

def name_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # set to None if short_description (nullable) is None
    # and model_fields_set contains the field
    if self.short_description is None and "short_description" in self.model_fields_set:
        _dict['shortDescription'] = None

    # set to None if information (nullable) is None
    # and model_fields_set contains the field
    if self.information is None and "information" in self.model_fields_set:
        _dict['information'] = None

    # set to None if project_owner_id (nullable) is None
    # and model_fields_set contains the field
    if self.project_owner_id is None and "project_owner_id" in self.model_fields_set:
        _dict['projectOwnerId'] = None

    # set to None if metadata_model_id (nullable) is None
    # and model_fields_set contains the field
    if self.metadata_model_id is None and "metadata_model_id" in self.model_fields_set:
        _dict['metadataModelId'] = None

    # set to None if storage_configuration_id (nullable) is None
    # and model_fields_set contains the field
    if self.storage_configuration_id is None and "storage_configuration_id" in self.model_fields_set:
        _dict['storageConfigurationId'] = None

    # set to None if storage_configuration_subfolder (nullable) is None
    # and model_fields_set contains the field
    if self.storage_configuration_subfolder is None and "storage_configuration_subfolder" in self.model_fields_set:
        _dict['storageConfigurationSubfolder'] = None

    # set to None if analysis_priority (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_priority is None and "analysis_priority" in self.model_fields_set:
        _dict['analysisPriority'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectDataCopyBatch (**data: Any)

Expand source code

class CreateProjectDataCopyBatch(BaseModel):
    """
    CreateProjectDataCopyBatch
    """ # noqa: E501
    items: List[CreateProjectDataCopyBatchItem]
    destination_folder_id: Optional[StrictStr] = Field(default=None, alias="destinationFolderId")
    copy_user_tags: StrictBool = Field(alias="copyUserTags")
    copy_technical_tags: StrictBool = Field(alias="copyTechnicalTags")
    copy_instrument_info: StrictBool = Field(alias="copyInstrumentInfo")
    action_on_exist: Annotated[str, Field(strict=True)] = Field(description="only applicable on files, not on folders", alias="actionOnExist")
    __properties: ClassVar[List[str]] = ["items", "destinationFolderId", "copyUserTags", "copyTechnicalTags", "copyInstrumentInfo", "actionOnExist"]

    @field_validator('action_on_exist')
    def action_on_exist_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"OVERWRITE|SKIP|RENAME", value):
            raise ValueError(r"must validate the regular expression /OVERWRITE|SKIP|RENAME/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectDataCopyBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectDataCopyBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [CreateProjectDataCopyBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "destinationFolderId": obj.get("destinationFolderId"),
            "copyUserTags": obj.get("copyUserTags"),
            "copyTechnicalTags": obj.get("copyTechnicalTags"),
            "copyInstrumentInfo": obj.get("copyInstrumentInfo"),
            "actionOnExist": obj.get("actionOnExist")
        })
        return _obj

CreateProjectDataCopyBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var action_on_exist : str

The type of the None singleton.

var copy_instrument_info : bool

The type of the None singleton.

var copy_technical_tags : bool

The type of the None singleton.

var copy_user_tags : bool

The type of the None singleton.

var destination_folder_id : str | None

The type of the None singleton.

var items : List[CreateProjectDataCopyBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def action_on_exist_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectDataCopyBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectDataCopyBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectDataCopyBatchItem (**data: Any)

Expand source code

class CreateProjectDataCopyBatchItem(BaseModel):
    """
    CreateProjectDataCopyBatchItem
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectDataCopyBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectDataCopyBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

CreateProjectDataCopyBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectDataCopyBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectDataCopyBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectDataLinkingBatch (**data: Any)

Expand source code

class CreateProjectDataLinkingBatch(BaseModel):
    """
    CreateProjectDataLinkingBatch
    """ # noqa: E501
    items: List[CreateProjectDataLinkingBatchItem]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectDataLinkingBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectDataLinkingBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [CreateProjectDataLinkingBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

CreateProjectDataLinkingBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[CreateProjectDataLinkingBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectDataLinkingBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectDataLinkingBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectDataLinkingBatchItem (**data: Any)

Expand source code

class CreateProjectDataLinkingBatchItem(BaseModel):
    """
    CreateProjectDataLinkingBatchItem
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectDataLinkingBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectDataLinkingBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

CreateProjectDataLinkingBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectDataLinkingBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectDataLinkingBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectDataMoveBatch (**data: Any)

Expand source code

class CreateProjectDataMoveBatch(BaseModel):
    """
    CreateProjectDataMoveBatch
    """ # noqa: E501
    items: List[CreateProjectDataMoveBatchItem]
    destination_folder_id: Optional[StrictStr] = Field(default=None, alias="destinationFolderId")
    __properties: ClassVar[List[str]] = ["items", "destinationFolderId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectDataMoveBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectDataMoveBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [CreateProjectDataMoveBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "destinationFolderId": obj.get("destinationFolderId")
        })
        return _obj

CreateProjectDataMoveBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var destination_folder_id : str | None

The type of the None singleton.

var items : List[CreateProjectDataMoveBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectDataMoveBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectDataMoveBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectDataMoveBatchItem (**data: Any)

Expand source code

class CreateProjectDataMoveBatchItem(BaseModel):
    """
    CreateProjectDataMoveBatchItem
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectDataMoveBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectDataMoveBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

CreateProjectDataMoveBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectDataMoveBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectDataMoveBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectDataUnlinkingBatch (**data: Any)

Expand source code

class CreateProjectDataUnlinkingBatch(BaseModel):
    """
    CreateProjectDataUnlinkingBatch
    """ # noqa: E501
    items: List[CreateProjectDataUnlinkingBatchItem]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectDataUnlinkingBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectDataUnlinkingBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [CreateProjectDataUnlinkingBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

CreateProjectDataUnlinkingBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[CreateProjectDataUnlinkingBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectDataUnlinkingBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectDataUnlinkingBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectDataUnlinkingBatchItem (**data: Any)

Expand source code

class CreateProjectDataUnlinkingBatchItem(BaseModel):
    """
    CreateProjectDataUnlinkingBatchItem
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectDataUnlinkingBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectDataUnlinkingBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

CreateProjectDataUnlinkingBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectDataUnlinkingBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectDataUnlinkingBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectDataUpdateBatch (**data: Any)

Expand source code

class CreateProjectDataUpdateBatch(BaseModel):
    """
    CreateProjectDataUpdateBatch
    """ # noqa: E501
    data_update_groups: List[DataUpdateGroup] = Field(alias="dataUpdateGroups")
    __properties: ClassVar[List[str]] = ["dataUpdateGroups"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectDataUpdateBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in data_update_groups (list)
        _items = []
        if self.data_update_groups:
            for _item_data_update_groups in self.data_update_groups:
                if _item_data_update_groups:
                    _items.append(_item_data_update_groups.to_dict())
            _dict['dataUpdateGroups'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectDataUpdateBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataUpdateGroups": [DataUpdateGroup.from_dict(_item) for _item in obj["dataUpdateGroups"]] if obj.get("dataUpdateGroups") is not None else None
        })
        return _obj

CreateProjectDataUpdateBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_update_groups : List[DataUpdateGroup]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectDataUpdateBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectDataUpdateBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in data_update_groups (list)
    _items = []
    if self.data_update_groups:
        for _item_data_update_groups in self.data_update_groups:
            if _item_data_update_groups:
                _items.append(_item_data_update_groups.to_dict())
        _dict['dataUpdateGroups'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectPermission (**data: Any)

Expand source code

class CreateProjectPermission(BaseModel):
    """
    CreateProjectPermission
    """ # noqa: E501
    role_project: StrictStr = Field(alias="roleProject")
    role_flow: StrictStr = Field(alias="roleFlow")
    role_base: StrictStr = Field(alias="roleBase")
    role_bench: StrictStr = Field(alias="roleBench")
    membership_type: StrictStr = Field(description="How users are invited to the project", alias="membershipType")
    user_id: Optional[StrictStr] = Field(default=None, description="the id of the user that should be given access, required when membershipType is USER", alias="userId")
    email_address: Optional[StrictStr] = Field(default=None, description="The email to invite a user on, required when membershipType is EMAIL", alias="emailAddress")
    workgroup_id: Optional[StrictStr] = Field(default=None, description="the id of the workgroup to give access, required when membershipType is WORKGROUP", alias="workgroupId")
    upload_allowed: StrictBool = Field(description="Indicates if uploading data is allowed or not.", alias="uploadAllowed")
    download_allowed: StrictBool = Field(description="Indicates if downloading data is allowed or not.", alias="downloadAllowed")
    __properties: ClassVar[List[str]] = ["roleProject", "roleFlow", "roleBase", "roleBench", "membershipType", "userId", "emailAddress", "workgroupId", "uploadAllowed", "downloadAllowed"]

    @field_validator('role_project')
    def role_project_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['NONE', 'VIEWER', 'CONTRIBUTOR', 'ADMINISTRATOR', 'DATA_PROVIDER']):
            raise ValueError("must be one of enum values ('NONE', 'VIEWER', 'CONTRIBUTOR', 'ADMINISTRATOR', 'DATA_PROVIDER')")
        return value

    @field_validator('role_flow')
    def role_flow_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['NONE', 'VIEWER', 'CONTRIBUTOR']):
            raise ValueError("must be one of enum values ('NONE', 'VIEWER', 'CONTRIBUTOR')")
        return value

    @field_validator('role_base')
    def role_base_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['NONE', 'VIEWER', 'CONTRIBUTOR']):
            raise ValueError("must be one of enum values ('NONE', 'VIEWER', 'CONTRIBUTOR')")
        return value

    @field_validator('role_bench')
    def role_bench_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['NONE', 'CONTRIBUTOR']):
            raise ValueError("must be one of enum values ('NONE', 'CONTRIBUTOR')")
        return value

    @field_validator('membership_type')
    def membership_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['USER', 'EMAIL', 'WORKGROUP']):
            raise ValueError("must be one of enum values ('USER', 'EMAIL', 'WORKGROUP')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectPermission from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if user_id (nullable) is None
        # and model_fields_set contains the field
        if self.user_id is None and "user_id" in self.model_fields_set:
            _dict['userId'] = None

        # set to None if email_address (nullable) is None
        # and model_fields_set contains the field
        if self.email_address is None and "email_address" in self.model_fields_set:
            _dict['emailAddress'] = None

        # set to None if workgroup_id (nullable) is None
        # and model_fields_set contains the field
        if self.workgroup_id is None and "workgroup_id" in self.model_fields_set:
            _dict['workgroupId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectPermission from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "roleProject": obj.get("roleProject"),
            "roleFlow": obj.get("roleFlow"),
            "roleBase": obj.get("roleBase"),
            "roleBench": obj.get("roleBench"),
            "membershipType": obj.get("membershipType"),
            "userId": obj.get("userId"),
            "emailAddress": obj.get("emailAddress"),
            "workgroupId": obj.get("workgroupId"),
            "uploadAllowed": obj.get("uploadAllowed"),
            "downloadAllowed": obj.get("downloadAllowed")
        })
        return _obj

CreateProjectPermission

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var download_allowed : bool

The type of the None singleton.

var email_address : str | None

The type of the None singleton.

var membership_type : str

The type of the None singleton.

var model_config

The type of the None singleton.

var role_base : str

The type of the None singleton.

var role_bench : str

The type of the None singleton.

var role_flow : str

The type of the None singleton.

var role_project : str

The type of the None singleton.

var upload_allowed : bool

The type of the None singleton.

var user_id : str | None

The type of the None singleton.

var workgroup_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectPermission from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectPermission from a JSON string

def membership_type_validate_enum(value)

Validates the enum

def role_base_validate_enum(value)

Validates the enum

def role_bench_validate_enum(value)

Validates the enum

def role_flow_validate_enum(value)

Validates the enum

def role_project_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if user_id (nullable) is None
    # and model_fields_set contains the field
    if self.user_id is None and "user_id" in self.model_fields_set:
        _dict['userId'] = None

    # set to None if email_address (nullable) is None
    # and model_fields_set contains the field
    if self.email_address is None and "email_address" in self.model_fields_set:
        _dict['emailAddress'] = None

    # set to None if workgroup_id (nullable) is None
    # and model_fields_set contains the field
    if self.workgroup_id is None and "workgroup_id" in self.model_fields_set:
        _dict['workgroupId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateProjectPermissionV4 (**data: Any)

Expand source code

class CreateProjectPermissionV4(BaseModel):
    """
    CreateProjectPermissionV4
    """ # noqa: E501
    role_project: Annotated[str, Field(strict=True)] = Field(alias="roleProject")
    role_flow: Annotated[str, Field(strict=True)] = Field(alias="roleFlow")
    role_base: Annotated[str, Field(strict=True)] = Field(alias="roleBase")
    role_bench: Annotated[str, Field(strict=True)] = Field(alias="roleBench")
    membership_type: StrictStr = Field(description="How users are invited to the project", alias="membershipType")
    user_id: Optional[StrictStr] = Field(default=None, description="the id of the user that should be given access, required when membershipType is USER", alias="userId")
    email_address: Optional[StrictStr] = Field(default=None, description="The email to invite a user on, required when membershipType is EMAIL", alias="emailAddress")
    workgroup_id: Optional[StrictStr] = Field(default=None, description="the id of the workgroup to give access, required when membershipType is WORKGROUP", alias="workgroupId")
    upload_allowed: StrictBool = Field(description="Indicates if uploading data is allowed or not.", alias="uploadAllowed")
    download_allowed: StrictBool = Field(description="Indicates if downloading data is allowed or not.", alias="downloadAllowed")
    __properties: ClassVar[List[str]] = ["roleProject", "roleFlow", "roleBase", "roleBench", "membershipType", "userId", "emailAddress", "workgroupId", "uploadAllowed", "downloadAllowed"]

    @field_validator('role_project')
    def role_project_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"NONE|VIEWER|CONTRIBUTOR|ADMINISTRATOR|DATA_PROVIDER", value):
            raise ValueError(r"must validate the regular expression /NONE|VIEWER|CONTRIBUTOR|ADMINISTRATOR|DATA_PROVIDER/")
        return value

    @field_validator('role_flow')
    def role_flow_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"NONE|VIEWER|CONTRIBUTOR", value):
            raise ValueError(r"must validate the regular expression /NONE|VIEWER|CONTRIBUTOR/")
        return value

    @field_validator('role_base')
    def role_base_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"NONE|VIEWER|CONTRIBUTOR", value):
            raise ValueError(r"must validate the regular expression /NONE|VIEWER|CONTRIBUTOR/")
        return value

    @field_validator('role_bench')
    def role_bench_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"NONE|CONTRIBUTOR|ADMINISTRATOR", value):
            raise ValueError(r"must validate the regular expression /NONE|CONTRIBUTOR|ADMINISTRATOR/")
        return value

    @field_validator('membership_type')
    def membership_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['USER', 'EMAIL', 'WORKGROUP']):
            raise ValueError("must be one of enum values ('USER', 'EMAIL', 'WORKGROUP')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateProjectPermissionV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if user_id (nullable) is None
        # and model_fields_set contains the field
        if self.user_id is None and "user_id" in self.model_fields_set:
            _dict['userId'] = None

        # set to None if email_address (nullable) is None
        # and model_fields_set contains the field
        if self.email_address is None and "email_address" in self.model_fields_set:
            _dict['emailAddress'] = None

        # set to None if workgroup_id (nullable) is None
        # and model_fields_set contains the field
        if self.workgroup_id is None and "workgroup_id" in self.model_fields_set:
            _dict['workgroupId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateProjectPermissionV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "roleProject": obj.get("roleProject"),
            "roleFlow": obj.get("roleFlow"),
            "roleBase": obj.get("roleBase"),
            "roleBench": obj.get("roleBench"),
            "membershipType": obj.get("membershipType"),
            "userId": obj.get("userId"),
            "emailAddress": obj.get("emailAddress"),
            "workgroupId": obj.get("workgroupId"),
            "uploadAllowed": obj.get("uploadAllowed"),
            "downloadAllowed": obj.get("downloadAllowed")
        })
        return _obj

CreateProjectPermissionV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var download_allowed : bool

The type of the None singleton.

var email_address : str | None

The type of the None singleton.

var membership_type : str

The type of the None singleton.

var model_config

The type of the None singleton.

var role_base : str

The type of the None singleton.

var role_bench : str

The type of the None singleton.

var role_flow : str

The type of the None singleton.

var role_project : str

The type of the None singleton.

var upload_allowed : bool

The type of the None singleton.

var user_id : str | None

The type of the None singleton.

var workgroup_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateProjectPermissionV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateProjectPermissionV4 from a JSON string

def membership_type_validate_enum(value)

Validates the enum

def role_base_validate_regular_expression(value)

Validates the regular expression

def role_bench_validate_regular_expression(value)

Validates the regular expression

def role_flow_validate_regular_expression(value)

Validates the regular expression

def role_project_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if user_id (nullable) is None
    # and model_fields_set contains the field
    if self.user_id is None and "user_id" in self.model_fields_set:
        _dict['userId'] = None

    # set to None if email_address (nullable) is None
    # and model_fields_set contains the field
    if self.email_address is None and "email_address" in self.model_fields_set:
        _dict['emailAddress'] = None

    # set to None if workgroup_id (nullable) is None
    # and model_fields_set contains the field
    if self.workgroup_id is None and "workgroup_id" in self.model_fields_set:
        _dict['workgroupId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateSample (**data: Any)

Expand source code

class CreateSample(BaseModel):
    """
    CreateSample
    """ # noqa: E501
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the sample.")
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="The description of the sample.")
    tags: Optional[OptionalSampleTags] = None
    __properties: ClassVar[List[str]] = ["name", "description", "tags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateSample from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if tags (nullable) is None
        # and model_fields_set contains the field
        if self.tags is None and "tags" in self.model_fields_set:
            _dict['tags'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateSample from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "description": obj.get("description"),
            "tags": OptionalSampleTags.from_dict(obj["tags"]) if obj.get("tags") is not None else None
        })
        return _obj

CreateSample

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var tags : OptionalSampleTags | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateSample from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateSample from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if tags (nullable) is None
    # and model_fields_set contains the field
    if self.tags is None and "tags" in self.model_fields_set:
        _dict['tags'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateSampleCreationBatch (**data: Any)

Expand source code

class CreateSampleCreationBatch(BaseModel):
    """
    CreateSampleCreationBatch
    """ # noqa: E501
    items: List[CreateSampleCreationBatchSampleItem]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateSampleCreationBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateSampleCreationBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [CreateSampleCreationBatchSampleItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

CreateSampleCreationBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[CreateSampleCreationBatchSampleItem]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateSampleCreationBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateSampleCreationBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateSampleCreationBatchDataItem (**data: Any)

Expand source code

class CreateSampleCreationBatchDataItem(BaseModel):
    """
    The data to be linked to the new sample.
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateSampleCreationBatchDataItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateSampleCreationBatchDataItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

The data to be linked to the new sample.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateSampleCreationBatchDataItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateSampleCreationBatchDataItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateSampleCreationBatchSampleItem (**data: Any)

Expand source code

class CreateSampleCreationBatchSampleItem(BaseModel):
    """
    CreateSampleCreationBatchSampleItem
    """ # noqa: E501
    sample_to_create: CreateSample = Field(alias="sampleToCreate")
    data_to_link: Optional[List[Optional[CreateSampleCreationBatchDataItem]]] = Field(default=None, description="The data to be linked to the new sample.", alias="dataToLink")
    complete_sample: StrictBool = Field(description="Indicates whether the sample must be completed.", alias="completeSample")
    __properties: ClassVar[List[str]] = ["sampleToCreate", "dataToLink", "completeSample"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateSampleCreationBatchSampleItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of sample_to_create
        if self.sample_to_create:
            _dict['sampleToCreate'] = self.sample_to_create.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in data_to_link (list)
        _items = []
        if self.data_to_link:
            for _item_data_to_link in self.data_to_link:
                if _item_data_to_link:
                    _items.append(_item_data_to_link.to_dict())
            _dict['dataToLink'] = _items
        # set to None if data_to_link (nullable) is None
        # and model_fields_set contains the field
        if self.data_to_link is None and "data_to_link" in self.model_fields_set:
            _dict['dataToLink'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateSampleCreationBatchSampleItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "sampleToCreate": CreateSample.from_dict(obj["sampleToCreate"]) if obj.get("sampleToCreate") is not None else None,
            "dataToLink": [CreateSampleCreationBatchDataItem.from_dict(_item) for _item in obj["dataToLink"]] if obj.get("dataToLink") is not None else None,
            "completeSample": obj.get("completeSample")
        })
        return _obj

CreateSampleCreationBatchSampleItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var complete_sample : bool

The type of the None singleton.

var data_to_link : List[CreateSampleCreationBatchDataItem | None] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var sample_to_create : CreateSample

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateSampleCreationBatchSampleItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateSampleCreationBatchSampleItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of sample_to_create
    if self.sample_to_create:
        _dict['sampleToCreate'] = self.sample_to_create.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in data_to_link (list)
    _items = []
    if self.data_to_link:
        for _item_data_to_link in self.data_to_link:
            if _item_data_to_link:
                _items.append(_item_data_to_link.to_dict())
        _dict['dataToLink'] = _items
    # set to None if data_to_link (nullable) is None
    # and model_fields_set contains the field
    if self.data_to_link is None and "data_to_link" in self.model_fields_set:
        _dict['dataToLink'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateStorageConfiguration (**data: Any)

Expand source code

class CreateStorageConfiguration(BaseModel):
    """
    CreateStorageConfiguration
    """ # noqa: E501
    name: Annotated[str, Field(min_length=3, strict=True, max_length=15)] = Field(description="The name of the configuration")
    description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=1000)]] = Field(default=None, description="An optional description")
    storage_credential_id: StrictStr = Field(description="The id of the storage credential", alias="storageCredentialId")
    type: StrictStr = Field(description="The type of configuration")
    aws_details: Optional[AWSDetails] = Field(default=None, alias="awsDetails")
    region_id: StrictStr = Field(description="The id of the region where the bucket will be located", alias="regionId")
    __properties: ClassVar[List[str]] = ["name", "description", "storageCredentialId", "type", "awsDetails", "regionId"]

    @field_validator('name')
    def name_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"^[a-z0-9][a-z0-9.-]*[a-z0-9]$", value):
            raise ValueError(r"must validate the regular expression /^[a-z0-9][a-z0-9.-]*[a-z0-9]$/")
        return value

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['AWS_S3']):
            raise ValueError("must be one of enum values ('AWS_S3')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateStorageConfiguration from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of aws_details
        if self.aws_details:
            _dict['awsDetails'] = self.aws_details.to_dict()
        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if aws_details (nullable) is None
        # and model_fields_set contains the field
        if self.aws_details is None and "aws_details" in self.model_fields_set:
            _dict['awsDetails'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateStorageConfiguration from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "description": obj.get("description"),
            "storageCredentialId": obj.get("storageCredentialId"),
            "type": obj.get("type"),
            "awsDetails": AWSDetails.from_dict(obj["awsDetails"]) if obj.get("awsDetails") is not None else None,
            "regionId": obj.get("regionId")
        })
        return _obj

CreateStorageConfiguration

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var aws_details : AWSDetails | None

The type of the None singleton.

var description : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var region_id : str

The type of the None singleton.

var storage_credential_id : str

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateStorageConfiguration from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateStorageConfiguration from a JSON string

def name_validate_regular_expression(value)

Validates the regular expression

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of aws_details
    if self.aws_details:
        _dict['awsDetails'] = self.aws_details.to_dict()
    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if aws_details (nullable) is None
    # and model_fields_set contains the field
    if self.aws_details is None and "aws_details" in self.model_fields_set:
        _dict['awsDetails'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateStorageCredential (**data: Any)

Expand source code

class CreateStorageCredential(BaseModel):
    """
    CreateStorageCredential
    """ # noqa: E501
    name: Annotated[str, Field(min_length=1, strict=True, max_length=150)] = Field(description="The name of the credentials")
    type: StrictStr = Field(description="The type of the credentials")
    aws_credentials: Optional[AwsCredentials] = Field(default=None, alias="awsCredentials")
    __properties: ClassVar[List[str]] = ["name", "type", "awsCredentials"]

    @field_validator('name')
    def name_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"^[a-zA-Z0-9_-]*$", value):
            raise ValueError(r"must validate the regular expression /^[a-zA-Z0-9_-]*$/")
        return value

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['AWS_USER']):
            raise ValueError("must be one of enum values ('AWS_USER')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateStorageCredential from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of aws_credentials
        if self.aws_credentials:
            _dict['awsCredentials'] = self.aws_credentials.to_dict()
        # set to None if aws_credentials (nullable) is None
        # and model_fields_set contains the field
        if self.aws_credentials is None and "aws_credentials" in self.model_fields_set:
            _dict['awsCredentials'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateStorageCredential from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "type": obj.get("type"),
            "awsCredentials": AwsCredentials.from_dict(obj["awsCredentials"]) if obj.get("awsCredentials") is not None else None
        })
        return _obj

CreateStorageCredential

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var aws_credentials : AwsCredentials | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateStorageCredential from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateStorageCredential from a JSON string

def name_validate_regular_expression(value)

Validates the regular expression

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of aws_credentials
    if self.aws_credentials:
        _dict['awsCredentials'] = self.aws_credentials.to_dict()
    # set to None if aws_credentials (nullable) is None
    # and model_fields_set contains the field
    if self.aws_credentials is None and "aws_credentials" in self.model_fields_set:
        _dict['awsCredentials'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateTemporaryCredentials (**data: Any)

Expand source code

class CreateTemporaryCredentials(BaseModel):
    """
    CreateTemporaryCredentials
    """ # noqa: E501
    credentials_format: Optional[StrictStr] = Field(default=None, description="The format in which temporary credentials have to be returned. If not provided, temporary credentials will be returned in a cloud specific format.", alias="credentialsFormat")
    read_only_credentials: Optional[StrictBool] = Field(default=None, description="The temporary credentials will be read-only.", alias="readOnlyCredentials")
    __properties: ClassVar[List[str]] = ["credentialsFormat", "readOnlyCredentials"]

    @field_validator('credentials_format')
    def credentials_format_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['RCLONE']):
            raise ValueError("must be one of enum values ('RCLONE')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateTemporaryCredentials from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if credentials_format (nullable) is None
        # and model_fields_set contains the field
        if self.credentials_format is None and "credentials_format" in self.model_fields_set:
            _dict['credentialsFormat'] = None

        # set to None if read_only_credentials (nullable) is None
        # and model_fields_set contains the field
        if self.read_only_credentials is None and "read_only_credentials" in self.model_fields_set:
            _dict['readOnlyCredentials'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateTemporaryCredentials from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "credentialsFormat": obj.get("credentialsFormat"),
            "readOnlyCredentials": obj.get("readOnlyCredentials")
        })
        return _obj

CreateTemporaryCredentials

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var credentials_format : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var read_only_credentials : bool | None

The type of the None singleton.

Static methods

def credentials_format_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateTemporaryCredentials from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateTemporaryCredentials from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if credentials_format (nullable) is None
    # and model_fields_set contains the field
    if self.credentials_format is None and "credentials_format" in self.model_fields_set:
        _dict['credentialsFormat'] = None

    # set to None if read_only_credentials (nullable) is None
    # and model_fields_set contains the field
    if self.read_only_credentials is None and "read_only_credentials" in self.model_fields_set:
        _dict['readOnlyCredentials'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateTermsOfUse (**data: Any)

Expand source code

class CreateTermsOfUse(BaseModel):
    """
    CreateTermsOfUse
    """ # noqa: E501
    terms_of_use: Annotated[str, Field(min_length=1, strict=True, max_length=2147483647)] = Field(description="Terms of Use for a bundle. Supports plain text or HTML.", alias="termsOfUse")
    requires_user_acceptance: StrictBool = Field(description="Flag indicating whether the Terms of Use should be accepted before using/viewing the bundle.", alias="requiresUserAcceptance")
    release_version: Annotated[str, Field(min_length=1, strict=True, max_length=4000)] = Field(description="Version number of the Terms of Use.", alias="releaseVersion")
    reset_acceptance_records: StrictBool = Field(description="Do you want to reset the acceptance records.", alias="resetAcceptanceRecords")
    __properties: ClassVar[List[str]] = ["termsOfUse", "requiresUserAcceptance", "releaseVersion", "resetAcceptanceRecords"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateTermsOfUse from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateTermsOfUse from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "termsOfUse": obj.get("termsOfUse"),
            "requiresUserAcceptance": obj.get("requiresUserAcceptance"),
            "releaseVersion": obj.get("releaseVersion"),
            "resetAcceptanceRecords": obj.get("resetAcceptanceRecords")
        })
        return _obj

CreateTermsOfUse

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var release_version : str

The type of the None singleton.

var requires_user_acceptance : bool

The type of the None singleton.

var reset_acceptance_records : bool

The type of the None singleton.

var terms_of_use : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateTermsOfUse from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateTermsOfUse from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CreateUploadRule (**data: Any)

Expand source code

class CreateUploadRule(BaseModel):
    """
    CreateUploadRule
    """ # noqa: E501
    code: Annotated[str, Field(min_length=1, strict=True, max_length=300)]
    active: Optional[StrictBool] = None
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = None
    local_folder: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The local folder to monitor. Files in this folder on your local environment will be uploaded to the specified project. Only files matching the filePattern will be uploaded.", alias="localFolder")
    file_pattern: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The regular expression to match a file name. eg: to match all files use '.*'", alias="filePattern")
    data_format_id: Optional[StrictStr] = Field(default=None, description="The format which will be assigned to the uploaded data. If not specified, an auto-detection of the format will be done.", alias="dataFormatId")
    project_id: StrictStr = Field(description="The project to which the data will be uploaded.", alias="projectId")
    __properties: ClassVar[List[str]] = ["code", "active", "description", "localFolder", "filePattern", "dataFormatId", "projectId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CreateUploadRule from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if active (nullable) is None
        # and model_fields_set contains the field
        if self.active is None and "active" in self.model_fields_set:
            _dict['active'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if data_format_id (nullable) is None
        # and model_fields_set contains the field
        if self.data_format_id is None and "data_format_id" in self.model_fields_set:
            _dict['dataFormatId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CreateUploadRule from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "active": obj.get("active"),
            "description": obj.get("description"),
            "localFolder": obj.get("localFolder"),
            "filePattern": obj.get("filePattern"),
            "dataFormatId": obj.get("dataFormatId"),
            "projectId": obj.get("projectId")
        })
        return _obj

CreateUploadRule

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var active : bool | None

The type of the None singleton.

var code : str

The type of the None singleton.

var data_format_id : str | None

The type of the None singleton.

var description : str | None

The type of the None singleton.

var file_pattern : str

The type of the None singleton.

var local_folder : str

The type of the None singleton.

var model_config

The type of the None singleton.

var project_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CreateUploadRule from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CreateUploadRule from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if active (nullable) is None
    # and model_fields_set contains the field
    if self.active is None and "active" in self.model_fields_set:
        _dict['active'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if data_format_id (nullable) is None
    # and model_fields_set contains the field
    if self.data_format_id is None and "data_format_id" in self.model_fields_set:
        _dict['dataFormatId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CustomNotificationSubscription (**data: Any)

Expand source code

class CustomNotificationSubscription(BaseModel):
    """
    CustomNotificationSubscription
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    custom_event_code: Annotated[str, Field(min_length=1, strict=True, max_length=20)] = Field(description="The custom event code to subscribe to", alias="customEventCode")
    filter_expression: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=2000)]] = Field(default=None, description="To be used when a notification applies to specific conditions.", alias="filterExpression")
    enabled: StrictBool = Field(description="Should this subscription be enabled or not?")
    notification_channel: NotificationChannel = Field(alias="notificationChannel")
    application: Optional[ApplicationV4] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "customEventCode", "filterExpression", "enabled", "notificationChannel", "application"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CustomNotificationSubscription from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of notification_channel
        if self.notification_channel:
            _dict['notificationChannel'] = self.notification_channel.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if filter_expression (nullable) is None
        # and model_fields_set contains the field
        if self.filter_expression is None and "filter_expression" in self.model_fields_set:
            _dict['filterExpression'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CustomNotificationSubscription from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "customEventCode": obj.get("customEventCode"),
            "filterExpression": obj.get("filterExpression"),
            "enabled": obj.get("enabled"),
            "notificationChannel": NotificationChannel.from_dict(obj["notificationChannel"]) if obj.get("notificationChannel") is not None else None,
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None
        })
        return _obj

CustomNotificationSubscription

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var application : ApplicationV4 | None

The type of the None singleton.

var custom_event_code : str

The type of the None singleton.

var enabled : bool

The type of the None singleton.

var filter_expression : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var notification_channel : NotificationChannel

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CustomNotificationSubscription from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CustomNotificationSubscription from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of notification_channel
    if self.notification_channel:
        _dict['notificationChannel'] = self.notification_channel.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if filter_expression (nullable) is None
    # and model_fields_set contains the field
    if self.filter_expression is None and "filter_expression" in self.model_fields_set:
        _dict['filterExpression'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CustomNotificationSubscriptionList (**data: Any)

Expand source code

class CustomNotificationSubscriptionList(BaseModel):
    """
    CustomNotificationSubscriptionList
    """ # noqa: E501
    items: List[CustomNotificationSubscription]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CustomNotificationSubscriptionList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CustomNotificationSubscriptionList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [CustomNotificationSubscription.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

CustomNotificationSubscriptionList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[CustomNotificationSubscription]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CustomNotificationSubscriptionList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CustomNotificationSubscriptionList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CwlAnalysisInput (*args, **kwargs)

Expand source code

class CwlAnalysisInput(BaseModel):
    """
    This object contains a \"oneOf\" construct. With the \"objectType\" attribute you can specify which object type you want to provide. Use \"STRUCTURED\" for type \"CreateAnalysisStructuredInput\" or use \"JSON\" for type \"CreateAnalysisJsonInput\".
    """
    # data type: CwlAnalysisStructuredInput
    oneof_schema_1_validator: Optional[CwlAnalysisStructuredInput] = None
    # data type: CwlAnalysisJsonInput
    oneof_schema_2_validator: Optional[CwlAnalysisJsonInput] = None
    actual_instance: Optional[Union[CwlAnalysisJsonInput, CwlAnalysisStructuredInput]] = None
    one_of_schemas: Set[str] = { "CwlAnalysisJsonInput", "CwlAnalysisStructuredInput" }

    model_config = ConfigDict(
        validate_assignment=True,
        protected_namespaces=(),
    )


    discriminator_value_class_map: Dict[str, str] = {
    }

    def __init__(self, *args, **kwargs) -> None:
        if args:
            if len(args) > 1:
                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
            if kwargs:
                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
            super().__init__(actual_instance=args[0])
        else:
            super().__init__(**kwargs)

    @field_validator('actual_instance')
    def actual_instance_must_validate_oneof(cls, v):
        instance = CwlAnalysisInput.model_construct()
        error_messages = []
        match = 0
        # validate data type: CwlAnalysisStructuredInput
        if not isinstance(v, CwlAnalysisStructuredInput):
            error_messages.append(f"Error! Input type `{type(v)}` is not `CwlAnalysisStructuredInput`")
        else:
            match += 1
        # validate data type: CwlAnalysisJsonInput
        if not isinstance(v, CwlAnalysisJsonInput):
            error_messages.append(f"Error! Input type `{type(v)}` is not `CwlAnalysisJsonInput`")
        else:
            match += 1
        if match > 1:
            # more than 1 match
            raise ValueError("Multiple matches found when setting `actual_instance` in CwlAnalysisInput with oneOf schemas: CwlAnalysisJsonInput, CwlAnalysisStructuredInput. Details: " + ", ".join(error_messages))
        elif match == 0:
            # no match
            raise ValueError("No match found when setting `actual_instance` in CwlAnalysisInput with oneOf schemas: CwlAnalysisJsonInput, CwlAnalysisStructuredInput. Details: " + ", ".join(error_messages))
        else:
            return v

    @classmethod
    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
        return cls.from_json(json.dumps(obj))

    @classmethod
    def from_json(cls, json_str: str) -> Self:
        """Returns the object represented by the json string"""
        instance = cls.model_construct()
        error_messages = []
        match = 0

        # deserialize data into CwlAnalysisStructuredInput
        try:
            instance.actual_instance = CwlAnalysisStructuredInput.from_json(json_str)
            match += 1
        except (ValidationError, ValueError) as e:
            error_messages.append(str(e))
        # deserialize data into CwlAnalysisJsonInput
        try:
            instance.actual_instance = CwlAnalysisJsonInput.from_json(json_str)
            match += 1
        except (ValidationError, ValueError) as e:
            error_messages.append(str(e))

        if match > 1:
            # more than 1 match
            raise ValueError("Multiple matches found when deserializing the JSON string into CwlAnalysisInput with oneOf schemas: CwlAnalysisJsonInput, CwlAnalysisStructuredInput. Details: " + ", ".join(error_messages))
        elif match == 0:
            # no match
            raise ValueError("No match found when deserializing the JSON string into CwlAnalysisInput with oneOf schemas: CwlAnalysisJsonInput, CwlAnalysisStructuredInput. Details: " + ", ".join(error_messages))
        else:
            return instance

    def to_json(self) -> str:
        """Returns the JSON representation of the actual instance"""
        if self.actual_instance is None:
            return "null"

        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
            return self.actual_instance.to_json()
        else:
            return json.dumps(self.actual_instance)

    def to_dict(self) -> Optional[Union[Dict[str, Any], CwlAnalysisJsonInput, CwlAnalysisStructuredInput]]:
        """Returns the dict representation of the actual instance"""
        if self.actual_instance is None:
            return None

        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
            return self.actual_instance.to_dict()
        else:
            # primitive type
            return self.actual_instance

    def to_str(self) -> str:
        """Returns the string representation of the actual instance"""
        return pprint.pformat(self.model_dump())

This object contains a "oneOf" construct. With the "objectType" attribute you can specify which object type you want to provide. Use "STRUCTURED" for type "CreateAnalysisStructuredInput" or use "JSON" for type "CreateAnalysisJsonInput".

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var actual_instance : CwlAnalysisJsonInput | CwlAnalysisStructuredInput | None

The type of the None singleton.

var discriminator_value_class_map : Dict[str, str]

The type of the None singleton.

var model_config

The type of the None singleton.

var one_of_schemas : Set[str]

The type of the None singleton.

var oneof_schema_1_validator : CwlAnalysisStructuredInput | None

The type of the None singleton.

var oneof_schema_2_validator : CwlAnalysisJsonInput | None

The type of the None singleton.

Static methods

def actual_instance_must_validate_oneof(v)

def from_dict(obj: Union[str, Dict[str, Any]]) ‑> Self

def from_json(json_str: str) ‑> Self

Returns the object represented by the json string

Methods

def to_dict(self) ‑> Dict[str, Any] | CwlAnalysisJsonInput | CwlAnalysisStructuredInput | None

Expand source code

def to_dict(self) -> Optional[Union[Dict[str, Any], CwlAnalysisJsonInput, CwlAnalysisStructuredInput]]:
    """Returns the dict representation of the actual instance"""
    if self.actual_instance is None:
        return None

    if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
        return self.actual_instance.to_dict()
    else:
        # primitive type
        return self.actual_instance

Returns the dict representation of the actual instance

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the actual instance"""
    if self.actual_instance is None:
        return "null"

    if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
        return self.actual_instance.to_json()
    else:
        return json.dumps(self.actual_instance)

Returns the JSON representation of the actual instance

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the actual instance"""
    return pprint.pformat(self.model_dump())

Returns the string representation of the actual instance

class CwlAnalysisInputJson (**data: Any)

Expand source code

class CwlAnalysisInputJson(BaseModel):
    """
    CwlAnalysisInputJson
    """ # noqa: E501
    input_json: StrictStr = Field(description="The input json of the CWL analysis.", alias="inputJson")
    __properties: ClassVar[List[str]] = ["inputJson"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CwlAnalysisInputJson from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CwlAnalysisInputJson from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "inputJson": obj.get("inputJson")
        })
        return _obj

CwlAnalysisInputJson

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var input_json : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CwlAnalysisInputJson from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CwlAnalysisInputJson from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CwlAnalysisJsonInput (**data: Any)

Expand source code

class CwlAnalysisJsonInput(BaseModel):
    """
    CwlAnalysisJsonInput
    """ # noqa: E501
    object_type: StrictStr = Field(alias="objectType")
    input_json: StrictStr = Field(description="Contains the input JSON, as an escaped JSON String.", alias="inputJson")
    data_ids: Optional[List[StrictStr]] = Field(default=None, alias="dataIds")
    mounts: Optional[List[Optional[AnalysisInputDataMount]]] = None
    external_data: Optional[List[Optional[AnalysisInputExternalData]]] = Field(default=None, alias="externalData")
    __properties: ClassVar[List[str]] = ["objectType", "inputJson", "dataIds", "mounts", "externalData"]

    @field_validator('object_type')
    def object_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['STRUCTURED', 'JSON']):
            raise ValueError("must be one of enum values ('STRUCTURED', 'JSON')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CwlAnalysisJsonInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in mounts (list)
        _items = []
        if self.mounts:
            for _item_mounts in self.mounts:
                if _item_mounts:
                    _items.append(_item_mounts.to_dict())
            _dict['mounts'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
        _items = []
        if self.external_data:
            for _item_external_data in self.external_data:
                if _item_external_data:
                    _items.append(_item_external_data.to_dict())
            _dict['externalData'] = _items
        # set to None if mounts (nullable) is None
        # and model_fields_set contains the field
        if self.mounts is None and "mounts" in self.model_fields_set:
            _dict['mounts'] = None

        # set to None if external_data (nullable) is None
        # and model_fields_set contains the field
        if self.external_data is None and "external_data" in self.model_fields_set:
            _dict['externalData'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CwlAnalysisJsonInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "objectType": obj.get("objectType"),
            "inputJson": obj.get("inputJson"),
            "dataIds": obj.get("dataIds"),
            "mounts": [AnalysisInputDataMount.from_dict(_item) for _item in obj["mounts"]] if obj.get("mounts") is not None else None,
            "externalData": [AnalysisInputExternalData.from_dict(_item) for _item in obj["externalData"]] if obj.get("externalData") is not None else None
        })
        return _obj

CwlAnalysisJsonInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_ids : List[str] | None

The type of the None singleton.

var external_data : List[AnalysisInputExternalData | None] | None

The type of the None singleton.

var input_json : str

The type of the None singleton.

var model_config

The type of the None singleton.

var mounts : List[AnalysisInputDataMount | None] | None

The type of the None singleton.

var object_type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CwlAnalysisJsonInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CwlAnalysisJsonInput from a JSON string

def object_type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in mounts (list)
    _items = []
    if self.mounts:
        for _item_mounts in self.mounts:
            if _item_mounts:
                _items.append(_item_mounts.to_dict())
        _dict['mounts'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
    _items = []
    if self.external_data:
        for _item_external_data in self.external_data:
            if _item_external_data:
                _items.append(_item_external_data.to_dict())
        _dict['externalData'] = _items
    # set to None if mounts (nullable) is None
    # and model_fields_set contains the field
    if self.mounts is None and "mounts" in self.model_fields_set:
        _dict['mounts'] = None

    # set to None if external_data (nullable) is None
    # and model_fields_set contains the field
    if self.external_data is None and "external_data" in self.model_fields_set:
        _dict['externalData'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CwlAnalysisOutputJson (**data: Any)

Expand source code

class CwlAnalysisOutputJson(BaseModel):
    """
    CwlAnalysisOutputJson
    """ # noqa: E501
    output_json: StrictStr = Field(description="The output json of the CWL analysis.", alias="outputJson")
    __properties: ClassVar[List[str]] = ["outputJson"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CwlAnalysisOutputJson from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CwlAnalysisOutputJson from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "outputJson": obj.get("outputJson")
        })
        return _obj

CwlAnalysisOutputJson

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var output_json : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CwlAnalysisOutputJson from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CwlAnalysisOutputJson from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CwlAnalysisStructuredInput (**data: Any)

Expand source code

class CwlAnalysisStructuredInput(BaseModel):
    """
    CwlAnalysisStructuredInput
    """ # noqa: E501
    object_type: StrictStr = Field(alias="objectType")
    inputs: List[AnalysisDataInput]
    parameters: Optional[List[Optional[AnalysisParameterInput]]] = None
    reference_data_parameters: Optional[List[Optional[AnalysisReferenceDataParameter]]] = Field(default=None, alias="referenceDataParameters")
    __properties: ClassVar[List[str]] = ["objectType", "inputs", "parameters", "referenceDataParameters"]

    @field_validator('object_type')
    def object_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['STRUCTURED', 'JSON']):
            raise ValueError("must be one of enum values ('STRUCTURED', 'JSON')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CwlAnalysisStructuredInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in inputs (list)
        _items = []
        if self.inputs:
            for _item_inputs in self.inputs:
                if _item_inputs:
                    _items.append(_item_inputs.to_dict())
            _dict['inputs'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in parameters (list)
        _items = []
        if self.parameters:
            for _item_parameters in self.parameters:
                if _item_parameters:
                    _items.append(_item_parameters.to_dict())
            _dict['parameters'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in reference_data_parameters (list)
        _items = []
        if self.reference_data_parameters:
            for _item_reference_data_parameters in self.reference_data_parameters:
                if _item_reference_data_parameters:
                    _items.append(_item_reference_data_parameters.to_dict())
            _dict['referenceDataParameters'] = _items
        # set to None if parameters (nullable) is None
        # and model_fields_set contains the field
        if self.parameters is None and "parameters" in self.model_fields_set:
            _dict['parameters'] = None

        # set to None if reference_data_parameters (nullable) is None
        # and model_fields_set contains the field
        if self.reference_data_parameters is None and "reference_data_parameters" in self.model_fields_set:
            _dict['referenceDataParameters'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CwlAnalysisStructuredInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "objectType": obj.get("objectType"),
            "inputs": [AnalysisDataInput.from_dict(_item) for _item in obj["inputs"]] if obj.get("inputs") is not None else None,
            "parameters": [AnalysisParameterInput.from_dict(_item) for _item in obj["parameters"]] if obj.get("parameters") is not None else None,
            "referenceDataParameters": [AnalysisReferenceDataParameter.from_dict(_item) for _item in obj["referenceDataParameters"]] if obj.get("referenceDataParameters") is not None else None
        })
        return _obj

CwlAnalysisStructuredInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var inputs : List[AnalysisDataInput]

The type of the None singleton.

var model_config

The type of the None singleton.

var object_type : str

The type of the None singleton.

var parameters : List[AnalysisParameterInput | None] | None

The type of the None singleton.

var reference_data_parameters : List[AnalysisReferenceDataParameter | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CwlAnalysisStructuredInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CwlAnalysisStructuredInput from a JSON string

def object_type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in inputs (list)
    _items = []
    if self.inputs:
        for _item_inputs in self.inputs:
            if _item_inputs:
                _items.append(_item_inputs.to_dict())
        _dict['inputs'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in parameters (list)
    _items = []
    if self.parameters:
        for _item_parameters in self.parameters:
            if _item_parameters:
                _items.append(_item_parameters.to_dict())
        _dict['parameters'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in reference_data_parameters (list)
    _items = []
    if self.reference_data_parameters:
        for _item_reference_data_parameters in self.reference_data_parameters:
            if _item_reference_data_parameters:
                _items.append(_item_reference_data_parameters.to_dict())
        _dict['referenceDataParameters'] = _items
    # set to None if parameters (nullable) is None
    # and model_fields_set contains the field
    if self.parameters is None and "parameters" in self.model_fields_set:
        _dict['parameters'] = None

    # set to None if reference_data_parameters (nullable) is None
    # and model_fields_set contains the field
    if self.reference_data_parameters is None and "reference_data_parameters" in self.model_fields_set:
        _dict['referenceDataParameters'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CwlAnalysisWithJsonInput (**data: Any)

Expand source code

class CwlAnalysisWithJsonInput(BaseModel):
    """
    CwlAnalysisWithJsonInput
    """ # noqa: E501
    input_json: StrictStr = Field(description="Contains the input JSON, as an escaped JSON String.", alias="inputJson")
    data_ids: Optional[List[StrictStr]] = Field(default=None, alias="dataIds")
    mounts: Optional[List[Optional[AnalysisInputDataMount]]] = None
    external_data: Optional[List[Optional[AnalysisInputExternalData]]] = Field(default=None, alias="externalData")
    __properties: ClassVar[List[str]] = ["inputJson", "dataIds", "mounts", "externalData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CwlAnalysisWithJsonInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in mounts (list)
        _items = []
        if self.mounts:
            for _item_mounts in self.mounts:
                if _item_mounts:
                    _items.append(_item_mounts.to_dict())
            _dict['mounts'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
        _items = []
        if self.external_data:
            for _item_external_data in self.external_data:
                if _item_external_data:
                    _items.append(_item_external_data.to_dict())
            _dict['externalData'] = _items
        # set to None if mounts (nullable) is None
        # and model_fields_set contains the field
        if self.mounts is None and "mounts" in self.model_fields_set:
            _dict['mounts'] = None

        # set to None if external_data (nullable) is None
        # and model_fields_set contains the field
        if self.external_data is None and "external_data" in self.model_fields_set:
            _dict['externalData'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CwlAnalysisWithJsonInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "inputJson": obj.get("inputJson"),
            "dataIds": obj.get("dataIds"),
            "mounts": [AnalysisInputDataMount.from_dict(_item) for _item in obj["mounts"]] if obj.get("mounts") is not None else None,
            "externalData": [AnalysisInputExternalData.from_dict(_item) for _item in obj["externalData"]] if obj.get("externalData") is not None else None
        })
        return _obj

CwlAnalysisWithJsonInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_ids : List[str] | None

The type of the None singleton.

var external_data : List[AnalysisInputExternalData | None] | None

The type of the None singleton.

var input_json : str

The type of the None singleton.

var model_config

The type of the None singleton.

var mounts : List[AnalysisInputDataMount | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CwlAnalysisWithJsonInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CwlAnalysisWithJsonInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in mounts (list)
    _items = []
    if self.mounts:
        for _item_mounts in self.mounts:
            if _item_mounts:
                _items.append(_item_mounts.to_dict())
        _dict['mounts'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
    _items = []
    if self.external_data:
        for _item_external_data in self.external_data:
            if _item_external_data:
                _items.append(_item_external_data.to_dict())
        _dict['externalData'] = _items
    # set to None if mounts (nullable) is None
    # and model_fields_set contains the field
    if self.mounts is None and "mounts" in self.model_fields_set:
        _dict['mounts'] = None

    # set to None if external_data (nullable) is None
    # and model_fields_set contains the field
    if self.external_data is None and "external_data" in self.model_fields_set:
        _dict['externalData'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CwlAnalysisWithStructuredInput (**data: Any)

Expand source code

class CwlAnalysisWithStructuredInput(BaseModel):
    """
    CwlAnalysisWithStructuredInput
    """ # noqa: E501
    inputs: List[AnalysisDataInput]
    parameters: Optional[List[Optional[AnalysisParameterInput]]] = None
    reference_data_parameters: Optional[List[Optional[AnalysisReferenceDataParameter]]] = Field(default=None, alias="referenceDataParameters")
    __properties: ClassVar[List[str]] = ["inputs", "parameters", "referenceDataParameters"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CwlAnalysisWithStructuredInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in inputs (list)
        _items = []
        if self.inputs:
            for _item_inputs in self.inputs:
                if _item_inputs:
                    _items.append(_item_inputs.to_dict())
            _dict['inputs'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in parameters (list)
        _items = []
        if self.parameters:
            for _item_parameters in self.parameters:
                if _item_parameters:
                    _items.append(_item_parameters.to_dict())
            _dict['parameters'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in reference_data_parameters (list)
        _items = []
        if self.reference_data_parameters:
            for _item_reference_data_parameters in self.reference_data_parameters:
                if _item_reference_data_parameters:
                    _items.append(_item_reference_data_parameters.to_dict())
            _dict['referenceDataParameters'] = _items
        # set to None if parameters (nullable) is None
        # and model_fields_set contains the field
        if self.parameters is None and "parameters" in self.model_fields_set:
            _dict['parameters'] = None

        # set to None if reference_data_parameters (nullable) is None
        # and model_fields_set contains the field
        if self.reference_data_parameters is None and "reference_data_parameters" in self.model_fields_set:
            _dict['referenceDataParameters'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CwlAnalysisWithStructuredInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "inputs": [AnalysisDataInput.from_dict(_item) for _item in obj["inputs"]] if obj.get("inputs") is not None else None,
            "parameters": [AnalysisParameterInput.from_dict(_item) for _item in obj["parameters"]] if obj.get("parameters") is not None else None,
            "referenceDataParameters": [AnalysisReferenceDataParameter.from_dict(_item) for _item in obj["referenceDataParameters"]] if obj.get("referenceDataParameters") is not None else None
        })
        return _obj

CwlAnalysisWithStructuredInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var inputs : List[AnalysisDataInput]

The type of the None singleton.

var model_config

The type of the None singleton.

var parameters : List[AnalysisParameterInput | None] | None

The type of the None singleton.

var reference_data_parameters : List[AnalysisReferenceDataParameter | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CwlAnalysisWithStructuredInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CwlAnalysisWithStructuredInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in inputs (list)
    _items = []
    if self.inputs:
        for _item_inputs in self.inputs:
            if _item_inputs:
                _items.append(_item_inputs.to_dict())
        _dict['inputs'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in parameters (list)
    _items = []
    if self.parameters:
        for _item_parameters in self.parameters:
            if _item_parameters:
                _items.append(_item_parameters.to_dict())
        _dict['parameters'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in reference_data_parameters (list)
    _items = []
    if self.reference_data_parameters:
        for _item_reference_data_parameters in self.reference_data_parameters:
            if _item_reference_data_parameters:
                _items.append(_item_reference_data_parameters.to_dict())
        _dict['referenceDataParameters'] = _items
    # set to None if parameters (nullable) is None
    # and model_fields_set contains the field
    if self.parameters is None and "parameters" in self.model_fields_set:
        _dict['parameters'] = None

    # set to None if reference_data_parameters (nullable) is None
    # and model_fields_set contains the field
    if self.reference_data_parameters is None and "reference_data_parameters" in self.model_fields_set:
        _dict['referenceDataParameters'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CwlJsonAnalysisInput (**data: Any)

Expand source code

class CwlJsonAnalysisInput(BaseModel):
    """
    CwlJsonAnalysisInput
    """ # noqa: E501
    fields: Optional[List[InputFormFieldValues]] = None
    groups: Optional[List[InputFormGroup]] = None
    __properties: ClassVar[List[str]] = ["fields", "groups"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CwlJsonAnalysisInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
        _items = []
        if self.fields:
            for _item_fields in self.fields:
                if _item_fields:
                    _items.append(_item_fields.to_dict())
            _dict['fields'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in groups (list)
        _items = []
        if self.groups:
            for _item_groups in self.groups:
                if _item_groups:
                    _items.append(_item_groups.to_dict())
            _dict['groups'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CwlJsonAnalysisInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "fields": [InputFormFieldValues.from_dict(_item) for _item in obj["fields"]] if obj.get("fields") is not None else None,
            "groups": [InputFormGroup.from_dict(_item) for _item in obj["groups"]] if obj.get("groups") is not None else None
        })
        return _obj

CwlJsonAnalysisInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var fields : List[InputFormFieldValues] | None

The type of the None singleton.

var groups : List[InputFormGroup] | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CwlJsonAnalysisInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CwlJsonAnalysisInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
    _items = []
    if self.fields:
        for _item_fields in self.fields:
            if _item_fields:
                _items.append(_item_fields.to_dict())
        _dict['fields'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in groups (list)
    _items = []
    if self.groups:
        for _item_groups in self.groups:
            if _item_groups:
                _items.append(_item_groups.to_dict())
        _dict['groups'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class CwlToolDefinitionList (**data: Any)

Expand source code

class CwlToolDefinitionList(BaseModel):
    """
    CwlToolDefinitionList
    """ # noqa: E501
    items: List[CWLToolDefinition]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of CwlToolDefinitionList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of CwlToolDefinitionList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [CWLToolDefinition.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

CwlToolDefinitionList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[CWLToolDefinition]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of CwlToolDefinitionList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of CwlToolDefinitionList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Data (**data: Any)

Expand source code

class Data(BaseModel):
    """
    Data
    """ # noqa: E501
    id: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The id of the file/folder as it was uploaded.")
    urn: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=2000)]] = Field(default=None, description="The URN of this data. The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")
    details: Optional[DataDetails] = None
    folder_details: Optional[FolderDetails] = Field(default=None, alias="folderDetails")
    __properties: ClassVar[List[str]] = ["id", "urn", "details", "folderDetails"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Data from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of details
        if self.details:
            _dict['details'] = self.details.to_dict()
        # override the default output from pydantic by calling `to_dict()` of folder_details
        if self.folder_details:
            _dict['folderDetails'] = self.folder_details.to_dict()
        # set to None if urn (nullable) is None
        # and model_fields_set contains the field
        if self.urn is None and "urn" in self.model_fields_set:
            _dict['urn'] = None

        # set to None if details (nullable) is None
        # and model_fields_set contains the field
        if self.details is None and "details" in self.model_fields_set:
            _dict['details'] = None

        # set to None if folder_details (nullable) is None
        # and model_fields_set contains the field
        if self.folder_details is None and "folder_details" in self.model_fields_set:
            _dict['folderDetails'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Data from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "urn": obj.get("urn"),
            "details": DataDetails.from_dict(obj["details"]) if obj.get("details") is not None else None,
            "folderDetails": FolderDetails.from_dict(obj["folderDetails"]) if obj.get("folderDetails") is not None else None
        })
        return _obj

Data

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var details : DataDetails | None

The type of the None singleton.

var folder_details : FolderDetails | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var urn : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Data from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Data from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of details
    if self.details:
        _dict['details'] = self.details.to_dict()
    # override the default output from pydantic by calling `to_dict()` of folder_details
    if self.folder_details:
        _dict['folderDetails'] = self.folder_details.to_dict()
    # set to None if urn (nullable) is None
    # and model_fields_set contains the field
    if self.urn is None and "urn" in self.model_fields_set:
        _dict['urn'] = None

    # set to None if details (nullable) is None
    # and model_fields_set contains the field
    if self.details is None and "details" in self.model_fields_set:
        _dict['details'] = None

    # set to None if folder_details (nullable) is None
    # and model_fields_set contains the field
    if self.folder_details is None and "folder_details" in self.model_fields_set:
        _dict['folderDetails'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataApi (api_client=None)

Expand source code

class DataApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_download_url_for_data_without_project_context(
        self,
        data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Download:
        """Retrieve a download URL for this data.

        Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

        :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
        :type data_urn: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_url_for_data_without_project_context_serialize(
            data_urn=data_urn,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Download",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_download_url_for_data_without_project_context_with_http_info(
        self,
        data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Download]:
        """Retrieve a download URL for this data.

        Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

        :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
        :type data_urn: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_url_for_data_without_project_context_serialize(
            data_urn=data_urn,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Download",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_download_url_for_data_without_project_context_without_preload_content(
        self,
        data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a download URL for this data.

        Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

        :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
        :type data_urn: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_url_for_data_without_project_context_serialize(
            data_urn=data_urn,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Download",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_download_url_for_data_without_project_context_serialize(
        self,
        data_urn,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if data_urn is not None:
            _path_params['dataUrn'] = data_urn
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/data/{dataUrn}:createDownloadUrl',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_inline_view_url_for_data_without_project_context(
        self,
        data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> InlineView:
        """Retrieve an URL for this data to use for inline view in a browser.

        Can be used to view a file directly from the region where it is located, no connector is needed.

        :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
        :type data_urn: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_inline_view_url_for_data_without_project_context_serialize(
            data_urn=data_urn,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InlineView",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_inline_view_url_for_data_without_project_context_with_http_info(
        self,
        data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[InlineView]:
        """Retrieve an URL for this data to use for inline view in a browser.

        Can be used to view a file directly from the region where it is located, no connector is needed.

        :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
        :type data_urn: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_inline_view_url_for_data_without_project_context_serialize(
            data_urn=data_urn,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InlineView",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_inline_view_url_for_data_without_project_context_without_preload_content(
        self,
        data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve an URL for this data to use for inline view in a browser.

        Can be used to view a file directly from the region where it is located, no connector is needed.

        :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
        :type data_urn: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_inline_view_url_for_data_without_project_context_serialize(
            data_urn=data_urn,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InlineView",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_inline_view_url_for_data_without_project_context_serialize(
        self,
        data_urn,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if data_urn is not None:
            _path_params['dataUrn'] = data_urn
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/data/{dataUrn}:createInlineViewUrl',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_data(
        self,
        data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Data:
        """Retrieve a data.


        :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
        :type data_urn: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_serialize(
            data_urn=data_urn,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Data",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_data_with_http_info(
        self,
        data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Data]:
        """Retrieve a data.


        :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
        :type data_urn: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_serialize(
            data_urn=data_urn,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Data",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_data_without_preload_content(
        self,
        data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a data.


        :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
        :type data_urn: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_serialize(
            data_urn=data_urn,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Data",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_data_serialize(
        self,
        data_urn,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if data_urn is not None:
            _path_params['dataUrn'] = data_urn
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/data/{dataUrn}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_download_url_for_data_without_project_context(self,
data_urn: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The format is urn:ilmn:ica:region:\\:data:\\#\\. The path can be omitted, in that case the hashtag (#) must also be omitted.')]) ‑> Download

Expand source code

@validate_call
def create_download_url_for_data_without_project_context(
    self,
    data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Download:
    """Retrieve a download URL for this data.

    Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

    :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
    :type data_urn: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_url_for_data_without_project_context_serialize(
        data_urn=data_urn,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Download",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a download URL for this data.

Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

:param data_urn: The format is urn:ilmn:ica:region:\<ID of the region>:data:\<ID of the data>#\<optional data path>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required) :type data_urn: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_url_for_data_without_project_context_with_http_info(self,
data_urn: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The format is urn:ilmn:ica:region:\\:data:\\#\\. The path can be omitted, in that case the hashtag (#) must also be omitted.')]) ‑> ApiResponse[Download]

Expand source code

@validate_call
def create_download_url_for_data_without_project_context_with_http_info(
    self,
    data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Download]:
    """Retrieve a download URL for this data.

    Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

    :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
    :type data_urn: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_url_for_data_without_project_context_serialize(
        data_urn=data_urn,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Download",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a download URL for this data.

Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

:param data_urn: The format is urn:ilmn:ica:region:\<ID of the region>:data:\<ID of the data>#\<optional data path>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required) :type data_urn: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_url_for_data_without_project_context_without_preload_content(self,
data_urn: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The format is urn:ilmn:ica:region:\\:data:\\#\\. The path can be omitted, in that case the hashtag (#) must also be omitted.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_download_url_for_data_without_project_context_without_preload_content(
    self,
    data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a download URL for this data.

    Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

    :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
    :type data_urn: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_url_for_data_without_project_context_serialize(
        data_urn=data_urn,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Download",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a download URL for this data.

Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

:param data_urn: The format is urn:ilmn:ica:region:\<ID of the region>:data:\<ID of the data>#\<optional data path>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required) :type data_urn: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_inline_view_url_for_data_without_project_context(self,
data_urn: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The format is urn:ilmn:ica:region:\\:data:\\#\\. The path can be omitted, in that case the hashtag (#) must also be omitted.')]) ‑> InlineView

Expand source code

@validate_call
def create_inline_view_url_for_data_without_project_context(
    self,
    data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> InlineView:
    """Retrieve an URL for this data to use for inline view in a browser.

    Can be used to view a file directly from the region where it is located, no connector is needed.

    :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
    :type data_urn: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_inline_view_url_for_data_without_project_context_serialize(
        data_urn=data_urn,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InlineView",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve an URL for this data to use for inline view in a browser.

Can be used to view a file directly from the region where it is located, no connector is needed.

:param data_urn: The format is urn:ilmn:ica:region:\<ID of the region>:data:\<ID of the data>#\<optional data path>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required) :type data_urn: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_inline_view_url_for_data_without_project_context_with_http_info(self,
data_urn: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The format is urn:ilmn:ica:region:\\:data:\\#\\. The path can be omitted, in that case the hashtag (#) must also be omitted.')]) ‑> ApiResponse[InlineView]

Expand source code

@validate_call
def create_inline_view_url_for_data_without_project_context_with_http_info(
    self,
    data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[InlineView]:
    """Retrieve an URL for this data to use for inline view in a browser.

    Can be used to view a file directly from the region where it is located, no connector is needed.

    :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
    :type data_urn: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_inline_view_url_for_data_without_project_context_serialize(
        data_urn=data_urn,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InlineView",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve an URL for this data to use for inline view in a browser.

Can be used to view a file directly from the region where it is located, no connector is needed.

:param data_urn: The format is urn:ilmn:ica:region:\<ID of the region>:data:\<ID of the data>#\<optional data path>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required) :type data_urn: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_inline_view_url_for_data_without_project_context_without_preload_content(self,
data_urn: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The format is urn:ilmn:ica:region:\\:data:\\#\\. The path can be omitted, in that case the hashtag (#) must also be omitted.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_inline_view_url_for_data_without_project_context_without_preload_content(
    self,
    data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve an URL for this data to use for inline view in a browser.

    Can be used to view a file directly from the region where it is located, no connector is needed.

    :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
    :type data_urn: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_inline_view_url_for_data_without_project_context_serialize(
        data_urn=data_urn,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InlineView",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve an URL for this data to use for inline view in a browser.

Can be used to view a file directly from the region where it is located, no connector is needed.

:param data_urn: The format is urn:ilmn:ica:region:\<ID of the region>:data:\<ID of the data>#\<optional data path>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required) :type data_urn: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data(self,
data_urn: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The format is urn:ilmn:ica:region:\\:data:\\#\\. The path can be omitted, in that case the hashtag (#) must also be omitted.')]) ‑> Data

Expand source code

@validate_call
def get_data(
    self,
    data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Data:
    """Retrieve a data.


    :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
    :type data_urn: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_serialize(
        data_urn=data_urn,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Data",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a data.

:param data_urn: The format is urn:ilmn:ica:region:\<ID of the region>:data:\<ID of the data>#\<optional data path>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required) :type data_urn: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_with_http_info(self,
data_urn: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The format is urn:ilmn:ica:region:\\:data:\\#\\. The path can be omitted, in that case the hashtag (#) must also be omitted.')]) ‑> ApiResponse[Data]

Expand source code

@validate_call
def get_data_with_http_info(
    self,
    data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Data]:
    """Retrieve a data.


    :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
    :type data_urn: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_serialize(
        data_urn=data_urn,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Data",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a data.

:param data_urn: The format is urn:ilmn:ica:region:\<ID of the region>:data:\<ID of the data>#\<optional data path>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required) :type data_urn: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_without_preload_content(self,
data_urn: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The format is urn:ilmn:ica:region:\\:data:\\#\\. The path can be omitted, in that case the hashtag (#) must also be omitted.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_data_without_preload_content(
    self,
    data_urn: Annotated[StrictStr, Field(description="The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a data.


    :param data_urn: The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required)
    :type data_urn: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_serialize(
        data_urn=data_urn,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Data",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a data.

:param data_urn: The format is urn:ilmn:ica:region:\<ID of the region>:data:\<ID of the data>#\<optional data path>. The path can be omitted, in that case the hashtag (#) must also be omitted. (required) :type data_urn: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class DataDetails (**data: Any)

Expand source code

class DataDetails(BaseModel):
    """
    DataDetails
    """ # noqa: E501
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    creator_id: Optional[StrictStr] = Field(default=None, alias="creatorId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    owning_project_id: StrictStr = Field(alias="owningProjectId")
    owning_project_name: Optional[StrictStr] = Field(default=None, alias="owningProjectName")
    name: StrictStr = Field(description="The name of the file/folder as it was uploaded.")
    path: Optional[StrictStr] = Field(default=None, description="The user friendly path of the parent of this data.")
    file_size_in_bytes: Optional[StrictInt] = Field(default=None, description="The size of the file in bytes. Folders do not have a size.", alias="fileSizeInBytes")
    status: StrictStr
    tags: DataTag
    format: Optional[DataFormat] = None
    data_type: StrictStr = Field(alias="dataType")
    object_e_tag: Optional[StrictStr] = Field(default=None, description="The file's ETag, as received from the cloud provider. Not to be confused with the ETag reponse header of this API.", alias="objectETag")
    stored_for_the_first_time_at: Optional[datetime] = Field(default=None, description="Specifies when the data object was stored for the first time", alias="storedForTheFirstTimeAt")
    region: Optional[Region] = None
    application: Optional[ApplicationV4] = None
    will_be_archived_at: Optional[datetime] = Field(default=None, description="Specifies when the data object will be archived.", alias="willBeArchivedAt")
    will_be_deleted_at: Optional[datetime] = Field(default=None, description="Specifies when the data object will be deleted.", alias="willBeDeletedAt")
    sequencing_run: Optional[SequencingRun] = Field(default=None, alias="sequencingRun")
    __properties: ClassVar[List[str]] = ["timeCreated", "timeModified", "creatorId", "tenantId", "tenantName", "owningProjectId", "owningProjectName", "name", "path", "fileSizeInBytes", "status", "tags", "format", "dataType", "objectETag", "storedForTheFirstTimeAt", "region", "application", "willBeArchivedAt", "willBeDeletedAt", "sequencingRun"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['PARTIAL', 'AVAILABLE', 'ARCHIVING', 'ARCHIVED', 'UNARCHIVING', 'DELETING']):
            raise ValueError("must be one of enum values ('PARTIAL', 'AVAILABLE', 'ARCHIVING', 'ARCHIVED', 'UNARCHIVING', 'DELETING')")
        return value

    @field_validator('data_type')
    def data_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['FILE', 'FOLDER']):
            raise ValueError("must be one of enum values ('FILE', 'FOLDER')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of format
        if self.format:
            _dict['format'] = self.format.to_dict()
        # override the default output from pydantic by calling `to_dict()` of region
        if self.region:
            _dict['region'] = self.region.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # override the default output from pydantic by calling `to_dict()` of sequencing_run
        if self.sequencing_run:
            _dict['sequencingRun'] = self.sequencing_run.to_dict()
        # set to None if creator_id (nullable) is None
        # and model_fields_set contains the field
        if self.creator_id is None and "creator_id" in self.model_fields_set:
            _dict['creatorId'] = None

        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if owning_project_name (nullable) is None
        # and model_fields_set contains the field
        if self.owning_project_name is None and "owning_project_name" in self.model_fields_set:
            _dict['owningProjectName'] = None

        # set to None if path (nullable) is None
        # and model_fields_set contains the field
        if self.path is None and "path" in self.model_fields_set:
            _dict['path'] = None

        # set to None if file_size_in_bytes (nullable) is None
        # and model_fields_set contains the field
        if self.file_size_in_bytes is None and "file_size_in_bytes" in self.model_fields_set:
            _dict['fileSizeInBytes'] = None

        # set to None if format (nullable) is None
        # and model_fields_set contains the field
        if self.format is None and "format" in self.model_fields_set:
            _dict['format'] = None

        # set to None if object_e_tag (nullable) is None
        # and model_fields_set contains the field
        if self.object_e_tag is None and "object_e_tag" in self.model_fields_set:
            _dict['objectETag'] = None

        # set to None if stored_for_the_first_time_at (nullable) is None
        # and model_fields_set contains the field
        if self.stored_for_the_first_time_at is None and "stored_for_the_first_time_at" in self.model_fields_set:
            _dict['storedForTheFirstTimeAt'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        # set to None if will_be_archived_at (nullable) is None
        # and model_fields_set contains the field
        if self.will_be_archived_at is None and "will_be_archived_at" in self.model_fields_set:
            _dict['willBeArchivedAt'] = None

        # set to None if will_be_deleted_at (nullable) is None
        # and model_fields_set contains the field
        if self.will_be_deleted_at is None and "will_be_deleted_at" in self.model_fields_set:
            _dict['willBeDeletedAt'] = None

        # set to None if sequencing_run (nullable) is None
        # and model_fields_set contains the field
        if self.sequencing_run is None and "sequencing_run" in self.model_fields_set:
            _dict['sequencingRun'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "creatorId": obj.get("creatorId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "owningProjectId": obj.get("owningProjectId"),
            "owningProjectName": obj.get("owningProjectName"),
            "name": obj.get("name"),
            "path": obj.get("path"),
            "fileSizeInBytes": obj.get("fileSizeInBytes"),
            "status": obj.get("status"),
            "tags": DataTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "format": DataFormat.from_dict(obj["format"]) if obj.get("format") is not None else None,
            "dataType": obj.get("dataType"),
            "objectETag": obj.get("objectETag"),
            "storedForTheFirstTimeAt": obj.get("storedForTheFirstTimeAt"),
            "region": Region.from_dict(obj["region"]) if obj.get("region") is not None else None,
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None,
            "willBeArchivedAt": obj.get("willBeArchivedAt"),
            "willBeDeletedAt": obj.get("willBeDeletedAt"),
            "sequencingRun": SequencingRun.from_dict(obj["sequencingRun"]) if obj.get("sequencingRun") is not None else None
        })
        return _obj

DataDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var application : ApplicationV4 | None

The type of the None singleton.

var creator_id : str | None

The type of the None singleton.

var data_type : str

The type of the None singleton.

var file_size_in_bytes : int | None

The type of the None singleton.

var format : DataFormat | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var object_e_tag : str | None

The type of the None singleton.

var owning_project_id : str

The type of the None singleton.

var owning_project_name : str | None

The type of the None singleton.

var path : str | None

The type of the None singleton.

var region : Region | None

The type of the None singleton.

var sequencing_run : SequencingRun | None

The type of the None singleton.

var status : str

The type of the None singleton.

var stored_for_the_first_time_at : datetime.datetime | None

The type of the None singleton.

var tags : DataTag

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var will_be_archived_at : datetime.datetime | None

The type of the None singleton.

var will_be_deleted_at : datetime.datetime | None

The type of the None singleton.

Static methods

def data_type_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataDetails from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of format
    if self.format:
        _dict['format'] = self.format.to_dict()
    # override the default output from pydantic by calling `to_dict()` of region
    if self.region:
        _dict['region'] = self.region.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # override the default output from pydantic by calling `to_dict()` of sequencing_run
    if self.sequencing_run:
        _dict['sequencingRun'] = self.sequencing_run.to_dict()
    # set to None if creator_id (nullable) is None
    # and model_fields_set contains the field
    if self.creator_id is None and "creator_id" in self.model_fields_set:
        _dict['creatorId'] = None

    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if owning_project_name (nullable) is None
    # and model_fields_set contains the field
    if self.owning_project_name is None and "owning_project_name" in self.model_fields_set:
        _dict['owningProjectName'] = None

    # set to None if path (nullable) is None
    # and model_fields_set contains the field
    if self.path is None and "path" in self.model_fields_set:
        _dict['path'] = None

    # set to None if file_size_in_bytes (nullable) is None
    # and model_fields_set contains the field
    if self.file_size_in_bytes is None and "file_size_in_bytes" in self.model_fields_set:
        _dict['fileSizeInBytes'] = None

    # set to None if format (nullable) is None
    # and model_fields_set contains the field
    if self.format is None and "format" in self.model_fields_set:
        _dict['format'] = None

    # set to None if object_e_tag (nullable) is None
    # and model_fields_set contains the field
    if self.object_e_tag is None and "object_e_tag" in self.model_fields_set:
        _dict['objectETag'] = None

    # set to None if stored_for_the_first_time_at (nullable) is None
    # and model_fields_set contains the field
    if self.stored_for_the_first_time_at is None and "stored_for_the_first_time_at" in self.model_fields_set:
        _dict['storedForTheFirstTimeAt'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    # set to None if will_be_archived_at (nullable) is None
    # and model_fields_set contains the field
    if self.will_be_archived_at is None and "will_be_archived_at" in self.model_fields_set:
        _dict['willBeArchivedAt'] = None

    # set to None if will_be_deleted_at (nullable) is None
    # and model_fields_set contains the field
    if self.will_be_deleted_at is None and "will_be_deleted_at" in self.model_fields_set:
        _dict['willBeDeletedAt'] = None

    # set to None if sequencing_run (nullable) is None
    # and model_fields_set contains the field
    if self.sequencing_run is None and "sequencing_run" in self.model_fields_set:
        _dict['sequencingRun'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataFormat (**data: Any)

Expand source code

class DataFormat(BaseModel):
    """
    DataFormat
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The code of the format. For example: FASTQ, BAM, ...")
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = None
    mime_type: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, alias="mimeType")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "code", "description", "mimeType"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataFormat from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if mime_type (nullable) is None
        # and model_fields_set contains the field
        if self.mime_type is None and "mime_type" in self.model_fields_set:
            _dict['mimeType'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataFormat from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "code": obj.get("code"),
            "description": obj.get("description"),
            "mimeType": obj.get("mimeType")
        })
        return _obj

DataFormat

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str

The type of the None singleton.

var description : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var mime_type : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataFormat from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataFormat from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if mime_type (nullable) is None
    # and model_fields_set contains the field
    if self.mime_type is None and "mime_type" in self.model_fields_set:
        _dict['mimeType'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataFormatApi (api_client=None)

Expand source code

class DataFormatApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_data_formats(
        self,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DataFormatPagedList:
        """Retrieve a list of data formats.


        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_formats_serialize(
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataFormatPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_data_formats_with_http_info(
        self,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DataFormatPagedList]:
        """Retrieve a list of data formats.


        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_formats_serialize(
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataFormatPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_data_formats_without_preload_content(
        self,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of data formats.


        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_formats_serialize(
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataFormatPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_data_formats_serialize(
        self,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/dataFormats',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_data_formats(self,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - code')] = None) ‑> DataFormatPagedList

Expand source code

@validate_call
def get_data_formats(
    self,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DataFormatPagedList:
    """Retrieve a list of data formats.


    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_formats_serialize(
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataFormatPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of data formats.

:param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - code :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_formats_with_http_info(self,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - code')] = None) ‑> ApiResponse[DataFormatPagedList]

Expand source code

@validate_call
def get_data_formats_with_http_info(
    self,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DataFormatPagedList]:
    """Retrieve a list of data formats.


    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_formats_serialize(
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataFormatPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of data formats.

:param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - code :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_formats_without_preload_content(self,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - code')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_data_formats_without_preload_content(
    self,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of data formats.


    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - code
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_formats_serialize(
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataFormatPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of data formats.

:param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - code :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class DataFormatPagedList (**data: Any)

Expand source code

class DataFormatPagedList(BaseModel):
    """
    DataFormatPagedList
    """ # noqa: E501
    items: List[Optional[DataFormat]]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataFormatPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataFormatPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [DataFormat.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

DataFormatPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[DataFormat | None]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataFormatPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataFormatPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataIdOrPathList (**data: Any)

Expand source code

class DataIdOrPathList(BaseModel):
    """
    DataIdOrPathList
    """ # noqa: E501
    data_ids: Optional[Annotated[List[StrictStr], Field(min_length=1, max_length=2147483647)]] = Field(default=None, alias="dataIds")
    data_paths: Optional[Annotated[List[StrictStr], Field(min_length=1, max_length=2147483647)]] = Field(default=None, alias="dataPaths")
    __properties: ClassVar[List[str]] = ["dataIds", "dataPaths"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataIdOrPathList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataIdOrPathList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataIds": obj.get("dataIds"),
            "dataPaths": obj.get("dataPaths")
        })
        return _obj

DataIdOrPathList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_ids : List[str] | None

The type of the None singleton.

var data_paths : List[str] | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataIdOrPathList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataIdOrPathList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataList (**data: Any)

Expand source code

class DataList(BaseModel):
    """
    DataList
    """ # noqa: E501
    items: List[Data]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Data.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

DataList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Data]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataPagedList (**data: Any)

Expand source code

class DataPagedList(BaseModel):
    """
    DataPagedList
    """ # noqa: E501
    items: List[Data]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Data.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

DataPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Data]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataTag (**data: Any)

Expand source code

class DataTag(BaseModel):
    """
    DataTag
    """ # noqa: E501
    technical_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="technicalTags")
    user_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="userTags")
    connector_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="connectorTags")
    run_in_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="runInTags")
    run_out_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="runOutTags")
    reference_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="referenceTags")
    __properties: ClassVar[List[str]] = ["technicalTags", "userTags", "connectorTags", "runInTags", "runOutTags", "referenceTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataTag from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if technical_tags (nullable) is None
        # and model_fields_set contains the field
        if self.technical_tags is None and "technical_tags" in self.model_fields_set:
            _dict['technicalTags'] = None

        # set to None if user_tags (nullable) is None
        # and model_fields_set contains the field
        if self.user_tags is None and "user_tags" in self.model_fields_set:
            _dict['userTags'] = None

        # set to None if connector_tags (nullable) is None
        # and model_fields_set contains the field
        if self.connector_tags is None and "connector_tags" in self.model_fields_set:
            _dict['connectorTags'] = None

        # set to None if run_in_tags (nullable) is None
        # and model_fields_set contains the field
        if self.run_in_tags is None and "run_in_tags" in self.model_fields_set:
            _dict['runInTags'] = None

        # set to None if run_out_tags (nullable) is None
        # and model_fields_set contains the field
        if self.run_out_tags is None and "run_out_tags" in self.model_fields_set:
            _dict['runOutTags'] = None

        # set to None if reference_tags (nullable) is None
        # and model_fields_set contains the field
        if self.reference_tags is None and "reference_tags" in self.model_fields_set:
            _dict['referenceTags'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataTag from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "technicalTags": obj.get("technicalTags"),
            "userTags": obj.get("userTags"),
            "connectorTags": obj.get("connectorTags"),
            "runInTags": obj.get("runInTags"),
            "runOutTags": obj.get("runOutTags"),
            "referenceTags": obj.get("referenceTags")
        })
        return _obj

DataTag

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var connector_tags : List[str | None] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var reference_tags : List[str | None] | None

The type of the None singleton.

var run_in_tags : List[str | None] | None

The type of the None singleton.

var run_out_tags : List[str | None] | None

The type of the None singleton.

var technical_tags : List[str | None] | None

The type of the None singleton.

var user_tags : List[str | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataTag from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataTag from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if technical_tags (nullable) is None
    # and model_fields_set contains the field
    if self.technical_tags is None and "technical_tags" in self.model_fields_set:
        _dict['technicalTags'] = None

    # set to None if user_tags (nullable) is None
    # and model_fields_set contains the field
    if self.user_tags is None and "user_tags" in self.model_fields_set:
        _dict['userTags'] = None

    # set to None if connector_tags (nullable) is None
    # and model_fields_set contains the field
    if self.connector_tags is None and "connector_tags" in self.model_fields_set:
        _dict['connectorTags'] = None

    # set to None if run_in_tags (nullable) is None
    # and model_fields_set contains the field
    if self.run_in_tags is None and "run_in_tags" in self.model_fields_set:
        _dict['runInTags'] = None

    # set to None if run_out_tags (nullable) is None
    # and model_fields_set contains the field
    if self.run_out_tags is None and "run_out_tags" in self.model_fields_set:
        _dict['runOutTags'] = None

    # set to None if reference_tags (nullable) is None
    # and model_fields_set contains the field
    if self.reference_tags is None and "reference_tags" in self.model_fields_set:
        _dict['referenceTags'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataTransfer (**data: Any)

Expand source code

class DataTransfer(BaseModel):
    """
    DataTransfer
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    direction: StrictStr
    connector: Optional[Connector] = None
    protocol: Optional[StrictStr] = None
    data_transferred: Annotated[int, Field(strict=True, ge=0)] = Field(description="The data transferred so far in bytes.", alias="dataTransferred")
    status: StrictStr
    status_message: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=1000)]] = Field(default=None, description="A message explaining the reason why the transfer is in the current status.", alias="statusMessage")
    duration: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The overall duration of of the transfer defined in seconds.")
    project: Optional[Project] = None
    data: Data
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "reference", "direction", "connector", "protocol", "dataTransferred", "status", "statusMessage", "duration", "project", "data"]

    @field_validator('direction')
    def direction_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['UPLOAD', 'DOWNLOAD', 'IMPORT']):
            raise ValueError("must be one of enum values ('UPLOAD', 'DOWNLOAD', 'IMPORT')")
        return value

    @field_validator('protocol')
    def protocol_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['HTTPS']):
            raise ValueError("must be one of enum values ('HTTPS')")
        return value

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['REQUESTED', 'ONGOING', 'SUCCEEDED', 'FAILED', 'ABORTED', 'ABORTREQUESTED', 'SCHEDULED']):
            raise ValueError("must be one of enum values ('REQUESTED', 'ONGOING', 'SUCCEEDED', 'FAILED', 'ABORTED', 'ABORTREQUESTED', 'SCHEDULED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataTransfer from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of connector
        if self.connector:
            _dict['connector'] = self.connector.to_dict()
        # override the default output from pydantic by calling `to_dict()` of project
        if self.project:
            _dict['project'] = self.project.to_dict()
        # override the default output from pydantic by calling `to_dict()` of data
        if self.data:
            _dict['data'] = self.data.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if connector (nullable) is None
        # and model_fields_set contains the field
        if self.connector is None and "connector" in self.model_fields_set:
            _dict['connector'] = None

        # set to None if protocol (nullable) is None
        # and model_fields_set contains the field
        if self.protocol is None and "protocol" in self.model_fields_set:
            _dict['protocol'] = None

        # set to None if status_message (nullable) is None
        # and model_fields_set contains the field
        if self.status_message is None and "status_message" in self.model_fields_set:
            _dict['statusMessage'] = None

        # set to None if duration (nullable) is None
        # and model_fields_set contains the field
        if self.duration is None and "duration" in self.model_fields_set:
            _dict['duration'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataTransfer from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "reference": obj.get("reference"),
            "direction": obj.get("direction"),
            "connector": Connector.from_dict(obj["connector"]) if obj.get("connector") is not None else None,
            "protocol": obj.get("protocol"),
            "dataTransferred": obj.get("dataTransferred"),
            "status": obj.get("status"),
            "statusMessage": obj.get("statusMessage"),
            "duration": obj.get("duration"),
            "project": Project.from_dict(obj["project"]) if obj.get("project") is not None else None,
            "data": Data.from_dict(obj["data"]) if obj.get("data") is not None else None
        })
        return _obj

DataTransfer

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var connector : Connector | None

The type of the None singleton.

var data : Data

The type of the None singleton.

var data_transferred : int

The type of the None singleton.

var direction : str

The type of the None singleton.

var duration : int | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var project : Project | None

The type of the None singleton.

var protocol : str | None

The type of the None singleton.

var reference : str

The type of the None singleton.

var status : str

The type of the None singleton.

var status_message : str | None

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def direction_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataTransfer from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataTransfer from a JSON string

def protocol_validate_enum(value)

Validates the enum

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of connector
    if self.connector:
        _dict['connector'] = self.connector.to_dict()
    # override the default output from pydantic by calling `to_dict()` of project
    if self.project:
        _dict['project'] = self.project.to_dict()
    # override the default output from pydantic by calling `to_dict()` of data
    if self.data:
        _dict['data'] = self.data.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if connector (nullable) is None
    # and model_fields_set contains the field
    if self.connector is None and "connector" in self.model_fields_set:
        _dict['connector'] = None

    # set to None if protocol (nullable) is None
    # and model_fields_set contains the field
    if self.protocol is None and "protocol" in self.model_fields_set:
        _dict['protocol'] = None

    # set to None if status_message (nullable) is None
    # and model_fields_set contains the field
    if self.status_message is None and "status_message" in self.model_fields_set:
        _dict['statusMessage'] = None

    # set to None if duration (nullable) is None
    # and model_fields_set contains the field
    if self.duration is None and "duration" in self.model_fields_set:
        _dict['duration'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataTransferPagedList (**data: Any)

Expand source code

class DataTransferPagedList(BaseModel):
    """
    DataTransferPagedList
    """ # noqa: E501
    items: List[DataTransfer]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataTransferPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataTransferPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [DataTransfer.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

DataTransferPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[DataTransfer]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataTransferPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataTransferPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataUpdateGroup (**data: Any)

Expand source code

class DataUpdateGroup(BaseModel):
    """
    Updates to apply.
    """ # noqa: E501
    data_ids: List[StrictStr] = Field(alias="dataIds")
    user_tags: Optional[TagUpdate] = Field(default=None, alias="userTags")
    technical_tags: Optional[TagUpdate] = Field(default=None, alias="technicalTags")
    will_be_archived_at: Optional[datetime] = Field(default=None, description="The timestamp when the data should be archived.", alias="willBeArchivedAt")
    will_be_deleted_at: Optional[datetime] = Field(default=None, description="The timestamp when the data should be deleted.", alias="willBeDeletedAt")
    __properties: ClassVar[List[str]] = ["dataIds", "userTags", "technicalTags", "willBeArchivedAt", "willBeDeletedAt"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataUpdateGroup from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of user_tags
        if self.user_tags:
            _dict['userTags'] = self.user_tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of technical_tags
        if self.technical_tags:
            _dict['technicalTags'] = self.technical_tags.to_dict()
        # set to None if user_tags (nullable) is None
        # and model_fields_set contains the field
        if self.user_tags is None and "user_tags" in self.model_fields_set:
            _dict['userTags'] = None

        # set to None if technical_tags (nullable) is None
        # and model_fields_set contains the field
        if self.technical_tags is None and "technical_tags" in self.model_fields_set:
            _dict['technicalTags'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataUpdateGroup from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataIds": obj.get("dataIds"),
            "userTags": TagUpdate.from_dict(obj["userTags"]) if obj.get("userTags") is not None else None,
            "technicalTags": TagUpdate.from_dict(obj["technicalTags"]) if obj.get("technicalTags") is not None else None,
            "willBeArchivedAt": obj.get("willBeArchivedAt"),
            "willBeDeletedAt": obj.get("willBeDeletedAt")
        })
        return _obj

Updates to apply.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_ids : List[str]

The type of the None singleton.

var model_config

The type of the None singleton.

var technical_tags : TagUpdate | None

The type of the None singleton.

var user_tags : TagUpdate | None

The type of the None singleton.

var will_be_archived_at : datetime.datetime | None

The type of the None singleton.

var will_be_deleted_at : datetime.datetime | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataUpdateGroup from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataUpdateGroup from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of user_tags
    if self.user_tags:
        _dict['userTags'] = self.user_tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of technical_tags
    if self.technical_tags:
        _dict['technicalTags'] = self.technical_tags.to_dict()
    # set to None if user_tags (nullable) is None
    # and model_fields_set contains the field
    if self.user_tags is None and "user_tags" in self.model_fields_set:
        _dict['userTags'] = None

    # set to None if technical_tags (nullable) is None
    # and model_fields_set contains the field
    if self.technical_tags is None and "technical_tags" in self.model_fields_set:
        _dict['technicalTags'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataUrlWithPath (**data: Any)

Expand source code

class DataUrlWithPath(BaseModel):
    """
    DataUrlWithPath
    """ # noqa: E501
    data_id: StrictStr = Field(description="The id of the file/folder as it was uploaded.", alias="dataId")
    data_urn: StrictStr = Field(description="The URN of this data. The format is urn:ilmn:ica:region:\\<ID of the region\\>:data:\\<ID of the data\\>#\\<optional data path\\>. The path can be omitted, in that case the hashtag (#) must also be omitted.", alias="dataUrn")
    data_path: StrictStr = Field(alias="dataPath")
    url: StrictStr
    __properties: ClassVar[List[str]] = ["dataId", "dataUrn", "dataPath", "url"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataUrlWithPath from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataUrlWithPath from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId"),
            "dataUrn": obj.get("dataUrn"),
            "dataPath": obj.get("dataPath"),
            "url": obj.get("url")
        })
        return _obj

DataUrlWithPath

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var data_path : str

The type of the None singleton.

var data_urn : str

The type of the None singleton.

var model_config

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataUrlWithPath from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataUrlWithPath from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DataUrlWithPathList (**data: Any)

Expand source code

class DataUrlWithPathList(BaseModel):
    """
    DataUrlWithPathList
    """ # noqa: E501
    items: List[DataUrlWithPath]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DataUrlWithPathList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DataUrlWithPathList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [DataUrlWithPath.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

DataUrlWithPathList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[DataUrlWithPath]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DataUrlWithPathList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DataUrlWithPathList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DockerImage (**data: Any)

Expand source code

class DockerImage(BaseModel):
    """
    DockerImage
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner: UserIdentifier
    tenant: TenantIdentifier
    name: StrictStr
    version: Optional[StrictStr] = None
    description: Optional[StrictStr] = None
    status: StrictStr
    type: StrictStr
    internal_docker_image_settings: Optional[InternalDockerImageSettings] = Field(default=None, alias="internalDockerImageSettings")
    external_docker_image_settings: Optional[ExternalDockerImageSettings] = Field(default=None, alias="externalDockerImageSettings")
    bench_settings: Optional[BenchSettings] = Field(default=None, alias="benchSettings")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "owner", "tenant", "name", "version", "description", "status", "type", "internalDockerImageSettings", "externalDockerImageSettings", "benchSettings"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['PARTIAL', 'AVAILABLE', 'DELETED', 'BUILDFAILED', 'DELETING']):
            raise ValueError("must be one of enum values ('PARTIAL', 'AVAILABLE', 'DELETED', 'BUILDFAILED', 'DELETING')")
        return value

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['TOOL', 'BENCH']):
            raise ValueError("must be one of enum values ('TOOL', 'BENCH')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DockerImage from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of owner
        if self.owner:
            _dict['owner'] = self.owner.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tenant
        if self.tenant:
            _dict['tenant'] = self.tenant.to_dict()
        # override the default output from pydantic by calling `to_dict()` of internal_docker_image_settings
        if self.internal_docker_image_settings:
            _dict['internalDockerImageSettings'] = self.internal_docker_image_settings.to_dict()
        # override the default output from pydantic by calling `to_dict()` of external_docker_image_settings
        if self.external_docker_image_settings:
            _dict['externalDockerImageSettings'] = self.external_docker_image_settings.to_dict()
        # override the default output from pydantic by calling `to_dict()` of bench_settings
        if self.bench_settings:
            _dict['benchSettings'] = self.bench_settings.to_dict()
        # set to None if version (nullable) is None
        # and model_fields_set contains the field
        if self.version is None and "version" in self.model_fields_set:
            _dict['version'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if internal_docker_image_settings (nullable) is None
        # and model_fields_set contains the field
        if self.internal_docker_image_settings is None and "internal_docker_image_settings" in self.model_fields_set:
            _dict['internalDockerImageSettings'] = None

        # set to None if external_docker_image_settings (nullable) is None
        # and model_fields_set contains the field
        if self.external_docker_image_settings is None and "external_docker_image_settings" in self.model_fields_set:
            _dict['externalDockerImageSettings'] = None

        # set to None if bench_settings (nullable) is None
        # and model_fields_set contains the field
        if self.bench_settings is None and "bench_settings" in self.model_fields_set:
            _dict['benchSettings'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DockerImage from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "owner": UserIdentifier.from_dict(obj["owner"]) if obj.get("owner") is not None else None,
            "tenant": TenantIdentifier.from_dict(obj["tenant"]) if obj.get("tenant") is not None else None,
            "name": obj.get("name"),
            "version": obj.get("version"),
            "description": obj.get("description"),
            "status": obj.get("status"),
            "type": obj.get("type"),
            "internalDockerImageSettings": InternalDockerImageSettings.from_dict(obj["internalDockerImageSettings"]) if obj.get("internalDockerImageSettings") is not None else None,
            "externalDockerImageSettings": ExternalDockerImageSettings.from_dict(obj["externalDockerImageSettings"]) if obj.get("externalDockerImageSettings") is not None else None,
            "benchSettings": BenchSettings.from_dict(obj["benchSettings"]) if obj.get("benchSettings") is not None else None
        })
        return _obj

DockerImage

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bench_settings : BenchSettings | None

The type of the None singleton.

var description : str | None

The type of the None singleton.

var external_docker_image_settings : ExternalDockerImageSettings | None

The type of the None singleton.

var id : str

The type of the None singleton.

var internal_docker_image_settings : InternalDockerImageSettings | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner : UserIdentifier

The type of the None singleton.

var status : str

The type of the None singleton.

var tenant : TenantIdentifier

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var type : str

The type of the None singleton.

var version : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DockerImage from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DockerImage from a JSON string

def status_validate_enum(value)

Validates the enum

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of owner
    if self.owner:
        _dict['owner'] = self.owner.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tenant
    if self.tenant:
        _dict['tenant'] = self.tenant.to_dict()
    # override the default output from pydantic by calling `to_dict()` of internal_docker_image_settings
    if self.internal_docker_image_settings:
        _dict['internalDockerImageSettings'] = self.internal_docker_image_settings.to_dict()
    # override the default output from pydantic by calling `to_dict()` of external_docker_image_settings
    if self.external_docker_image_settings:
        _dict['externalDockerImageSettings'] = self.external_docker_image_settings.to_dict()
    # override the default output from pydantic by calling `to_dict()` of bench_settings
    if self.bench_settings:
        _dict['benchSettings'] = self.bench_settings.to_dict()
    # set to None if version (nullable) is None
    # and model_fields_set contains the field
    if self.version is None and "version" in self.model_fields_set:
        _dict['version'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if internal_docker_image_settings (nullable) is None
    # and model_fields_set contains the field
    if self.internal_docker_image_settings is None and "internal_docker_image_settings" in self.model_fields_set:
        _dict['internalDockerImageSettings'] = None

    # set to None if external_docker_image_settings (nullable) is None
    # and model_fields_set contains the field
    if self.external_docker_image_settings is None and "external_docker_image_settings" in self.model_fields_set:
        _dict['externalDockerImageSettings'] = None

    # set to None if bench_settings (nullable) is None
    # and model_fields_set contains the field
    if self.bench_settings is None and "bench_settings" in self.model_fields_set:
        _dict['benchSettings'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DockerImageAccess (**data: Any)

Expand source code

class DockerImageAccess(BaseModel):
    """
    DockerImageAccess
    """ # noqa: E501
    web: StrictBool
    console: StrictBool
    __properties: ClassVar[List[str]] = ["web", "console"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DockerImageAccess from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DockerImageAccess from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "web": obj.get("web"),
            "console": obj.get("console")
        })
        return _obj

DockerImageAccess

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var console : bool

The type of the None singleton.

var model_config

The type of the None singleton.

var web : bool

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DockerImageAccess from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DockerImageAccess from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DockerImageApi (api_client=None)

Expand source code

class DockerImageApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def add_regions(
        self,
        image_id: StrictStr,
        docker_image_region_list: DockerImageRegionList,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Add regions to an existing Docker image.


        :param image_id: (required)
        :type image_id: str
        :param docker_image_region_list: (required)
        :type docker_image_region_list: DockerImageRegionList
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._add_regions_serialize(
            image_id=image_id,
            docker_image_region_list=docker_image_region_list,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def add_regions_with_http_info(
        self,
        image_id: StrictStr,
        docker_image_region_list: DockerImageRegionList,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Add regions to an existing Docker image.


        :param image_id: (required)
        :type image_id: str
        :param docker_image_region_list: (required)
        :type docker_image_region_list: DockerImageRegionList
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._add_regions_serialize(
            image_id=image_id,
            docker_image_region_list=docker_image_region_list,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def add_regions_without_preload_content(
        self,
        image_id: StrictStr,
        docker_image_region_list: DockerImageRegionList,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Add regions to an existing Docker image.


        :param image_id: (required)
        :type image_id: str
        :param docker_image_region_list: (required)
        :type docker_image_region_list: DockerImageRegionList
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._add_regions_serialize(
            image_id=image_id,
            docker_image_region_list=docker_image_region_list,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _add_regions_serialize(
        self,
        image_id,
        docker_image_region_list,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if image_id is not None:
            _path_params['imageId'] = image_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if docker_image_region_list is not None:
            _body_params = docker_image_region_list


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/dockerImages/{imageId}:addRegions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_external_docker_image(
        self,
        create_external_docker_image: CreateExternalDockerImage,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DockerImage:
        """Create an external Docker image.


        :param create_external_docker_image: (required)
        :type create_external_docker_image: CreateExternalDockerImage
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_external_docker_image_serialize(
            create_external_docker_image=create_external_docker_image,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "DockerImage",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_external_docker_image_with_http_info(
        self,
        create_external_docker_image: CreateExternalDockerImage,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DockerImage]:
        """Create an external Docker image.


        :param create_external_docker_image: (required)
        :type create_external_docker_image: CreateExternalDockerImage
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_external_docker_image_serialize(
            create_external_docker_image=create_external_docker_image,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "DockerImage",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_external_docker_image_without_preload_content(
        self,
        create_external_docker_image: CreateExternalDockerImage,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create an external Docker image.


        :param create_external_docker_image: (required)
        :type create_external_docker_image: CreateExternalDockerImage
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_external_docker_image_serialize(
            create_external_docker_image=create_external_docker_image,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "DockerImage",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_external_docker_image_serialize(
        self,
        create_external_docker_image,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_external_docker_image is not None:
            _body_params = create_external_docker_image


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/dockerImages:createExternal',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_internal_docker_image(
        self,
        create_internal_docker_image: CreateInternalDockerImage,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DockerImage:
        """Create an internal Docker image.


        :param create_internal_docker_image: (required)
        :type create_internal_docker_image: CreateInternalDockerImage
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_internal_docker_image_serialize(
            create_internal_docker_image=create_internal_docker_image,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "DockerImage",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_internal_docker_image_with_http_info(
        self,
        create_internal_docker_image: CreateInternalDockerImage,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DockerImage]:
        """Create an internal Docker image.


        :param create_internal_docker_image: (required)
        :type create_internal_docker_image: CreateInternalDockerImage
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_internal_docker_image_serialize(
            create_internal_docker_image=create_internal_docker_image,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "DockerImage",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_internal_docker_image_without_preload_content(
        self,
        create_internal_docker_image: CreateInternalDockerImage,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create an internal Docker image.


        :param create_internal_docker_image: (required)
        :type create_internal_docker_image: CreateInternalDockerImage
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_internal_docker_image_serialize(
            create_internal_docker_image=create_internal_docker_image,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "DockerImage",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_internal_docker_image_serialize(
        self,
        create_internal_docker_image,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_internal_docker_image is not None:
            _body_params = create_internal_docker_image


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/dockerImages:createInternal',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_docker_image(
        self,
        image_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DockerImage:
        """Retrieve a Docker image. Only the Docker image the user has access to can be retrieved.


        :param image_id: (required)
        :type image_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_docker_image_serialize(
            image_id=image_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DockerImage",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_docker_image_with_http_info(
        self,
        image_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DockerImage]:
        """Retrieve a Docker image. Only the Docker image the user has access to can be retrieved.


        :param image_id: (required)
        :type image_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_docker_image_serialize(
            image_id=image_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DockerImage",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_docker_image_without_preload_content(
        self,
        image_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a Docker image. Only the Docker image the user has access to can be retrieved.


        :param image_id: (required)
        :type image_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_docker_image_serialize(
            image_id=image_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DockerImage",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_docker_image_serialize(
        self,
        image_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if image_id is not None:
            _path_params['imageId'] = image_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/dockerImages/{imageId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_docker_images(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DockerImageList:
        """Retrieve a list of Docker images. Only the Docker images the user has access to are returned.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_docker_images_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DockerImageList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_docker_images_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DockerImageList]:
        """Retrieve a list of Docker images. Only the Docker images the user has access to are returned.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_docker_images_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DockerImageList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_docker_images_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of Docker images. Only the Docker images the user has access to are returned.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_docker_images_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DockerImageList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_docker_images_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/dockerImages',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def remove_regions(
        self,
        image_id: StrictStr,
        docker_image_region_list: DockerImageRegionList,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Remove regions to an existing Docker image.


        :param image_id: (required)
        :type image_id: str
        :param docker_image_region_list: (required)
        :type docker_image_region_list: DockerImageRegionList
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._remove_regions_serialize(
            image_id=image_id,
            docker_image_region_list=docker_image_region_list,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def remove_regions_with_http_info(
        self,
        image_id: StrictStr,
        docker_image_region_list: DockerImageRegionList,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Remove regions to an existing Docker image.


        :param image_id: (required)
        :type image_id: str
        :param docker_image_region_list: (required)
        :type docker_image_region_list: DockerImageRegionList
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._remove_regions_serialize(
            image_id=image_id,
            docker_image_region_list=docker_image_region_list,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def remove_regions_without_preload_content(
        self,
        image_id: StrictStr,
        docker_image_region_list: DockerImageRegionList,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Remove regions to an existing Docker image.


        :param image_id: (required)
        :type image_id: str
        :param docker_image_region_list: (required)
        :type docker_image_region_list: DockerImageRegionList
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._remove_regions_serialize(
            image_id=image_id,
            docker_image_region_list=docker_image_region_list,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _remove_regions_serialize(
        self,
        image_id,
        docker_image_region_list,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if image_id is not None:
            _path_params['imageId'] = image_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if docker_image_region_list is not None:
            _body_params = docker_image_region_list


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/dockerImages/{imageId}:removeRegions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def add_regions(self,
image_id: Annotated[str, Strict(strict=True)],
docker_image_region_list: DockerImageRegionList) ‑> None

Expand source code

@validate_call
def add_regions(
    self,
    image_id: StrictStr,
    docker_image_region_list: DockerImageRegionList,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Add regions to an existing Docker image.


    :param image_id: (required)
    :type image_id: str
    :param docker_image_region_list: (required)
    :type docker_image_region_list: DockerImageRegionList
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._add_regions_serialize(
        image_id=image_id,
        docker_image_region_list=docker_image_region_list,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Add regions to an existing Docker image.

:param image_id: (required) :type image_id: str :param docker_image_region_list: (required) :type docker_image_region_list: DockerImageRegionList :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def add_regions_with_http_info(self,
image_id: Annotated[str, Strict(strict=True)],
docker_image_region_list: DockerImageRegionList) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def add_regions_with_http_info(
    self,
    image_id: StrictStr,
    docker_image_region_list: DockerImageRegionList,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Add regions to an existing Docker image.


    :param image_id: (required)
    :type image_id: str
    :param docker_image_region_list: (required)
    :type docker_image_region_list: DockerImageRegionList
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._add_regions_serialize(
        image_id=image_id,
        docker_image_region_list=docker_image_region_list,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Add regions to an existing Docker image.

:param image_id: (required) :type image_id: str :param docker_image_region_list: (required) :type docker_image_region_list: DockerImageRegionList :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def add_regions_without_preload_content(self,
image_id: Annotated[str, Strict(strict=True)],
docker_image_region_list: DockerImageRegionList) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def add_regions_without_preload_content(
    self,
    image_id: StrictStr,
    docker_image_region_list: DockerImageRegionList,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Add regions to an existing Docker image.


    :param image_id: (required)
    :type image_id: str
    :param docker_image_region_list: (required)
    :type docker_image_region_list: DockerImageRegionList
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._add_regions_serialize(
        image_id=image_id,
        docker_image_region_list=docker_image_region_list,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Add regions to an existing Docker image.

:param image_id: (required) :type image_id: str :param docker_image_region_list: (required) :type docker_image_region_list: DockerImageRegionList :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_external_docker_image(self,
create_external_docker_image: CreateExternalDockerImage) ‑> DockerImage

Expand source code

@validate_call
def create_external_docker_image(
    self,
    create_external_docker_image: CreateExternalDockerImage,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DockerImage:
    """Create an external Docker image.


    :param create_external_docker_image: (required)
    :type create_external_docker_image: CreateExternalDockerImage
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_external_docker_image_serialize(
        create_external_docker_image=create_external_docker_image,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "DockerImage",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create an external Docker image.

:param create_external_docker_image: (required) :type create_external_docker_image: CreateExternalDockerImage :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_external_docker_image_with_http_info(self,
create_external_docker_image: CreateExternalDockerImage) ‑> ApiResponse[DockerImage]

Expand source code

@validate_call
def create_external_docker_image_with_http_info(
    self,
    create_external_docker_image: CreateExternalDockerImage,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DockerImage]:
    """Create an external Docker image.


    :param create_external_docker_image: (required)
    :type create_external_docker_image: CreateExternalDockerImage
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_external_docker_image_serialize(
        create_external_docker_image=create_external_docker_image,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "DockerImage",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create an external Docker image.

:param create_external_docker_image: (required) :type create_external_docker_image: CreateExternalDockerImage :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_external_docker_image_without_preload_content(self,
create_external_docker_image: CreateExternalDockerImage) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_external_docker_image_without_preload_content(
    self,
    create_external_docker_image: CreateExternalDockerImage,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create an external Docker image.


    :param create_external_docker_image: (required)
    :type create_external_docker_image: CreateExternalDockerImage
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_external_docker_image_serialize(
        create_external_docker_image=create_external_docker_image,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "DockerImage",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create an external Docker image.

:param create_external_docker_image: (required) :type create_external_docker_image: CreateExternalDockerImage :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_internal_docker_image(self,
create_internal_docker_image: CreateInternalDockerImage) ‑> DockerImage

Expand source code

@validate_call
def create_internal_docker_image(
    self,
    create_internal_docker_image: CreateInternalDockerImage,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DockerImage:
    """Create an internal Docker image.


    :param create_internal_docker_image: (required)
    :type create_internal_docker_image: CreateInternalDockerImage
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_internal_docker_image_serialize(
        create_internal_docker_image=create_internal_docker_image,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "DockerImage",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create an internal Docker image.

:param create_internal_docker_image: (required) :type create_internal_docker_image: CreateInternalDockerImage :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_internal_docker_image_with_http_info(self,
create_internal_docker_image: CreateInternalDockerImage) ‑> ApiResponse[DockerImage]

Expand source code

@validate_call
def create_internal_docker_image_with_http_info(
    self,
    create_internal_docker_image: CreateInternalDockerImage,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DockerImage]:
    """Create an internal Docker image.


    :param create_internal_docker_image: (required)
    :type create_internal_docker_image: CreateInternalDockerImage
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_internal_docker_image_serialize(
        create_internal_docker_image=create_internal_docker_image,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "DockerImage",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create an internal Docker image.

:param create_internal_docker_image: (required) :type create_internal_docker_image: CreateInternalDockerImage :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_internal_docker_image_without_preload_content(self,
create_internal_docker_image: CreateInternalDockerImage) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_internal_docker_image_without_preload_content(
    self,
    create_internal_docker_image: CreateInternalDockerImage,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create an internal Docker image.


    :param create_internal_docker_image: (required)
    :type create_internal_docker_image: CreateInternalDockerImage
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_internal_docker_image_serialize(
        create_internal_docker_image=create_internal_docker_image,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "DockerImage",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create an internal Docker image.

:param create_internal_docker_image: (required) :type create_internal_docker_image: CreateInternalDockerImage :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_docker_image(self, image_id: Annotated[str, Strict(strict=True)]) ‑> DockerImage

Expand source code

@validate_call
def get_docker_image(
    self,
    image_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DockerImage:
    """Retrieve a Docker image. Only the Docker image the user has access to can be retrieved.


    :param image_id: (required)
    :type image_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_docker_image_serialize(
        image_id=image_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DockerImage",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a Docker image. Only the Docker image the user has access to can be retrieved.

:param image_id: (required) :type image_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_docker_image_with_http_info(self, image_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[DockerImage]

Expand source code

@validate_call
def get_docker_image_with_http_info(
    self,
    image_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DockerImage]:
    """Retrieve a Docker image. Only the Docker image the user has access to can be retrieved.


    :param image_id: (required)
    :type image_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_docker_image_serialize(
        image_id=image_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DockerImage",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a Docker image. Only the Docker image the user has access to can be retrieved.

:param image_id: (required) :type image_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_docker_image_without_preload_content(self, image_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_docker_image_without_preload_content(
    self,
    image_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a Docker image. Only the Docker image the user has access to can be retrieved.


    :param image_id: (required)
    :type image_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_docker_image_serialize(
        image_id=image_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DockerImage",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a Docker image. Only the Docker image the user has access to can be retrieved.

:param image_id: (required) :type image_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_docker_images(self) ‑> DockerImageList

Expand source code

@validate_call
def get_docker_images(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DockerImageList:
    """Retrieve a list of Docker images. Only the Docker images the user has access to are returned.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_docker_images_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DockerImageList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of Docker images. Only the Docker images the user has access to are returned.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_docker_images_with_http_info(self) ‑> ApiResponse[DockerImageList]

Expand source code

@validate_call
def get_docker_images_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DockerImageList]:
    """Retrieve a list of Docker images. Only the Docker images the user has access to are returned.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_docker_images_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DockerImageList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of Docker images. Only the Docker images the user has access to are returned.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_docker_images_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_docker_images_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of Docker images. Only the Docker images the user has access to are returned.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_docker_images_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DockerImageList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of Docker images. Only the Docker images the user has access to are returned.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def remove_regions(self,
image_id: Annotated[str, Strict(strict=True)],
docker_image_region_list: DockerImageRegionList) ‑> None

Expand source code

@validate_call
def remove_regions(
    self,
    image_id: StrictStr,
    docker_image_region_list: DockerImageRegionList,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Remove regions to an existing Docker image.


    :param image_id: (required)
    :type image_id: str
    :param docker_image_region_list: (required)
    :type docker_image_region_list: DockerImageRegionList
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._remove_regions_serialize(
        image_id=image_id,
        docker_image_region_list=docker_image_region_list,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Remove regions to an existing Docker image.

:param image_id: (required) :type image_id: str :param docker_image_region_list: (required) :type docker_image_region_list: DockerImageRegionList :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def remove_regions_with_http_info(self,
image_id: Annotated[str, Strict(strict=True)],
docker_image_region_list: DockerImageRegionList) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def remove_regions_with_http_info(
    self,
    image_id: StrictStr,
    docker_image_region_list: DockerImageRegionList,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Remove regions to an existing Docker image.


    :param image_id: (required)
    :type image_id: str
    :param docker_image_region_list: (required)
    :type docker_image_region_list: DockerImageRegionList
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._remove_regions_serialize(
        image_id=image_id,
        docker_image_region_list=docker_image_region_list,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Remove regions to an existing Docker image.

:param image_id: (required) :type image_id: str :param docker_image_region_list: (required) :type docker_image_region_list: DockerImageRegionList :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def remove_regions_without_preload_content(self,
image_id: Annotated[str, Strict(strict=True)],
docker_image_region_list: DockerImageRegionList) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def remove_regions_without_preload_content(
    self,
    image_id: StrictStr,
    docker_image_region_list: DockerImageRegionList,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Remove regions to an existing Docker image.


    :param image_id: (required)
    :type image_id: str
    :param docker_image_region_list: (required)
    :type docker_image_region_list: DockerImageRegionList
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._remove_regions_serialize(
        image_id=image_id,
        docker_image_region_list=docker_image_region_list,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Remove regions to an existing Docker image.

:param image_id: (required) :type image_id: str :param docker_image_region_list: (required) :type docker_image_region_list: DockerImageRegionList :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class DockerImageList (**data: Any)

Expand source code

class DockerImageList(BaseModel):
    """
    DockerImageList
    """ # noqa: E501
    items: List[DockerImage]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DockerImageList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DockerImageList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [DockerImage.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

DockerImageList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[DockerImage]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DockerImageList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DockerImageList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DockerImageRegion (**data: Any)

Expand source code

class DockerImageRegion(BaseModel):
    """
    DockerImageRegion
    """ # noqa: E501
    region: Optional[RegionV4] = None
    url: Optional[StrictStr] = None
    __properties: ClassVar[List[str]] = ["region", "url"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DockerImageRegion from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of region
        if self.region:
            _dict['region'] = self.region.to_dict()
        # set to None if region (nullable) is None
        # and model_fields_set contains the field
        if self.region is None and "region" in self.model_fields_set:
            _dict['region'] = None

        # set to None if url (nullable) is None
        # and model_fields_set contains the field
        if self.url is None and "url" in self.model_fields_set:
            _dict['url'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DockerImageRegion from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "region": RegionV4.from_dict(obj["region"]) if obj.get("region") is not None else None,
            "url": obj.get("url")
        })
        return _obj

DockerImageRegion

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var region : RegionV4 | None

The type of the None singleton.

var url : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DockerImageRegion from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DockerImageRegion from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of region
    if self.region:
        _dict['region'] = self.region.to_dict()
    # set to None if region (nullable) is None
    # and model_fields_set contains the field
    if self.region is None and "region" in self.model_fields_set:
        _dict['region'] = None

    # set to None if url (nullable) is None
    # and model_fields_set contains the field
    if self.url is None and "url" in self.model_fields_set:
        _dict['url'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DockerImageRegionList (**data: Any)

Expand source code

class DockerImageRegionList(BaseModel):
    """
    DockerImageRegionList
    """ # noqa: E501
    region_ids: List[StrictStr] = Field(alias="regionIds")
    __properties: ClassVar[List[str]] = ["regionIds"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DockerImageRegionList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DockerImageRegionList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "regionIds": obj.get("regionIds")
        })
        return _obj

DockerImageRegionList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var region_ids : List[str]

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DockerImageRegionList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DockerImageRegionList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Download (**data: Any)

Expand source code

class Download(BaseModel):
    """
    Download
    """ # noqa: E501
    url: StrictStr = Field(description="A pre-signed url which is temporarily available for downloading the data.")
    __properties: ClassVar[List[str]] = ["url"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Download from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Download from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "url": obj.get("url")
        })
        return _obj

Download

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Download from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Download from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DownloadRule (**data: Any)

Expand source code

class DownloadRule(BaseModel):
    """
    DownloadRule
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    code: StrictStr
    active: Optional[StrictBool] = None
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = None
    sequence: Annotated[int, Field(strict=True, ge=0)] = Field(description="Defines the order of the rule.")
    format_code: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="Regular expression to select which format this rule applies to.", alias="formatCode")
    project_name: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="Regular expression to select which project this rule applies to.", alias="projectName")
    target_local_folder: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The local folder where to write the data.", alias="targetLocalFolder")
    file_name_expression: Optional[StrictStr] = Field(default=None, description="Will allow the filename to be modified including a set of variables", alias="fileNameExpression")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "code", "active", "description", "sequence", "formatCode", "projectName", "targetLocalFolder", "fileNameExpression"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DownloadRule from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if active (nullable) is None
        # and model_fields_set contains the field
        if self.active is None and "active" in self.model_fields_set:
            _dict['active'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if format_code (nullable) is None
        # and model_fields_set contains the field
        if self.format_code is None and "format_code" in self.model_fields_set:
            _dict['formatCode'] = None

        # set to None if project_name (nullable) is None
        # and model_fields_set contains the field
        if self.project_name is None and "project_name" in self.model_fields_set:
            _dict['projectName'] = None

        # set to None if file_name_expression (nullable) is None
        # and model_fields_set contains the field
        if self.file_name_expression is None and "file_name_expression" in self.model_fields_set:
            _dict['fileNameExpression'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DownloadRule from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "code": obj.get("code"),
            "active": obj.get("active"),
            "description": obj.get("description"),
            "sequence": obj.get("sequence"),
            "formatCode": obj.get("formatCode"),
            "projectName": obj.get("projectName"),
            "targetLocalFolder": obj.get("targetLocalFolder"),
            "fileNameExpression": obj.get("fileNameExpression")
        })
        return _obj

DownloadRule

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var active : bool | None

The type of the None singleton.

var code : str

The type of the None singleton.

var description : str | None

The type of the None singleton.

var file_name_expression : str | None

The type of the None singleton.

var format_code : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var project_name : str | None

The type of the None singleton.

var sequence : int

The type of the None singleton.

var target_local_folder : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DownloadRule from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DownloadRule from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if active (nullable) is None
    # and model_fields_set contains the field
    if self.active is None and "active" in self.model_fields_set:
        _dict['active'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if format_code (nullable) is None
    # and model_fields_set contains the field
    if self.format_code is None and "format_code" in self.model_fields_set:
        _dict['formatCode'] = None

    # set to None if project_name (nullable) is None
    # and model_fields_set contains the field
    if self.project_name is None and "project_name" in self.model_fields_set:
        _dict['projectName'] = None

    # set to None if file_name_expression (nullable) is None
    # and model_fields_set contains the field
    if self.file_name_expression is None and "file_name_expression" in self.model_fields_set:
        _dict['fileNameExpression'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class DownloadRuleList (**data: Any)

Expand source code

class DownloadRuleList(BaseModel):
    """
    DownloadRuleList
    """ # noqa: E501
    items: List[DownloadRule]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of DownloadRuleList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of DownloadRuleList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [DownloadRule.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

DownloadRuleList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[DownloadRule]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of DownloadRuleList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of DownloadRuleList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class EntitledBundleApi (api_client=None)

Expand source code

class EntitledBundleApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def accept_terms_of_use_entitled_bundle(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle where the terms of use are accepted of.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Accept terms of use for an entitled bundle


        :param entitled_bundle_id: The ID of the entitled bundle where the terms of use are accepted of. (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._accept_terms_of_use_entitled_bundle_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def accept_terms_of_use_entitled_bundle_with_http_info(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle where the terms of use are accepted of.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Accept terms of use for an entitled bundle


        :param entitled_bundle_id: The ID of the entitled bundle where the terms of use are accepted of. (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._accept_terms_of_use_entitled_bundle_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def accept_terms_of_use_entitled_bundle_without_preload_content(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle where the terms of use are accepted of.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Accept terms of use for an entitled bundle


        :param entitled_bundle_id: The ID of the entitled bundle where the terms of use are accepted of. (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._accept_terms_of_use_entitled_bundle_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _accept_terms_of_use_entitled_bundle_serialize(
        self,
        entitled_bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if entitled_bundle_id is not None:
            _path_params['entitledBundleId'] = entitled_bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/entitledbundles/{entitledBundleId}/termsOfUse:accept',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_entitled_bundle(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Bundle:
        """Retrieve an entitled bundle.


        :param entitled_bundle_id: The ID of the entitled bundle to retrieve (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundle_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Bundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_entitled_bundle_with_http_info(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Bundle]:
        """Retrieve an entitled bundle.


        :param entitled_bundle_id: The ID of the entitled bundle to retrieve (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundle_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Bundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_entitled_bundle_without_preload_content(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve an entitled bundle.


        :param entitled_bundle_id: The ID of the entitled bundle to retrieve (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundle_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Bundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_entitled_bundle_serialize(
        self,
        entitled_bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if entitled_bundle_id is not None:
            _path_params['entitledBundleId'] = entitled_bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/entitledbundles/{entitledBundleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_entitled_bundle_terms_of_use(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> TermsOfUse:
        """Retrieve the last version of terms of use for an entitled bundle.


        :param entitled_bundle_id: The ID of the entitled bundle of the terms of use to retrieve (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundle_terms_of_use_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_entitled_bundle_terms_of_use_with_http_info(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[TermsOfUse]:
        """Retrieve the last version of terms of use for an entitled bundle.


        :param entitled_bundle_id: The ID of the entitled bundle of the terms of use to retrieve (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundle_terms_of_use_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_entitled_bundle_terms_of_use_without_preload_content(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the last version of terms of use for an entitled bundle.


        :param entitled_bundle_id: The ID of the entitled bundle of the terms of use to retrieve (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundle_terms_of_use_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUse",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_entitled_bundle_terms_of_use_serialize(
        self,
        entitled_bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if entitled_bundle_id is not None:
            _path_params['entitledBundleId'] = entitled_bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/entitledbundles/{entitledBundleId}/termsOfUse',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_entitled_bundle_terms_of_use_acceptance(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use acceptance records.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> TermsOfUseAcceptance:
        """Retrieve the acceptance record for an entitled bundle for the current user.


        :param entitled_bundle_id: The ID of the entitled bundle of the terms of use acceptance records. (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundle_terms_of_use_acceptance_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUseAcceptance",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_entitled_bundle_terms_of_use_acceptance_with_http_info(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use acceptance records.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[TermsOfUseAcceptance]:
        """Retrieve the acceptance record for an entitled bundle for the current user.


        :param entitled_bundle_id: The ID of the entitled bundle of the terms of use acceptance records. (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundle_terms_of_use_acceptance_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUseAcceptance",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_entitled_bundle_terms_of_use_acceptance_without_preload_content(
        self,
        entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use acceptance records.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the acceptance record for an entitled bundle for the current user.


        :param entitled_bundle_id: The ID of the entitled bundle of the terms of use acceptance records. (required)
        :type entitled_bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundle_terms_of_use_acceptance_serialize(
            entitled_bundle_id=entitled_bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TermsOfUseAcceptance",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_entitled_bundle_terms_of_use_acceptance_serialize(
        self,
        entitled_bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if entitled_bundle_id is not None:
            _path_params['entitledBundleId'] = entitled_bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/entitledbundles/{entitledBundleId}/termsOfUse/userAcceptance/currentUser',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_entitled_bundles(
        self,
        search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BundlePagedList:
        """Retrieve a list of entitled bundles.


        :param search: Search
        :type search: str
        :param user_tags: User tags to filter on
        :type user_tags: str
        :param technical_tags: Technical tags to filter on
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundles_serialize(
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundlePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_entitled_bundles_with_http_info(
        self,
        search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BundlePagedList]:
        """Retrieve a list of entitled bundles.


        :param search: Search
        :type search: str
        :param user_tags: User tags to filter on
        :type user_tags: str
        :param technical_tags: Technical tags to filter on
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundles_serialize(
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundlePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_entitled_bundles_without_preload_content(
        self,
        search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of entitled bundles.


        :param search: Search
        :type search: str
        :param user_tags: User tags to filter on
        :type user_tags: str
        :param technical_tags: Technical tags to filter on
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_entitled_bundles_serialize(
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BundlePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_entitled_bundles_serialize(
        self,
        search,
        user_tags,
        technical_tags,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if search is not None:
            
            _query_params.append(('search', search))
            
        if user_tags is not None:
            
            _query_params.append(('userTags', user_tags))
            
        if technical_tags is not None:
            
            _query_params.append(('technicalTags', technical_tags))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/entitledbundles',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def accept_terms_of_use_entitled_bundle(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle where the terms of use are accepted of.')]) ‑> None

Expand source code

@validate_call
def accept_terms_of_use_entitled_bundle(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle where the terms of use are accepted of.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Accept terms of use for an entitled bundle


    :param entitled_bundle_id: The ID of the entitled bundle where the terms of use are accepted of. (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._accept_terms_of_use_entitled_bundle_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Accept terms of use for an entitled bundle

:param entitled_bundle_id: The ID of the entitled bundle where the terms of use are accepted of. (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def accept_terms_of_use_entitled_bundle_with_http_info(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle where the terms of use are accepted of.')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def accept_terms_of_use_entitled_bundle_with_http_info(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle where the terms of use are accepted of.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Accept terms of use for an entitled bundle


    :param entitled_bundle_id: The ID of the entitled bundle where the terms of use are accepted of. (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._accept_terms_of_use_entitled_bundle_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Accept terms of use for an entitled bundle

:param entitled_bundle_id: The ID of the entitled bundle where the terms of use are accepted of. (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def accept_terms_of_use_entitled_bundle_without_preload_content(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle where the terms of use are accepted of.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def accept_terms_of_use_entitled_bundle_without_preload_content(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle where the terms of use are accepted of.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Accept terms of use for an entitled bundle


    :param entitled_bundle_id: The ID of the entitled bundle where the terms of use are accepted of. (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._accept_terms_of_use_entitled_bundle_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Accept terms of use for an entitled bundle

:param entitled_bundle_id: The ID of the entitled bundle where the terms of use are accepted of. (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundle(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle to retrieve')]) ‑> Bundle

Expand source code

@validate_call
def get_entitled_bundle(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Bundle:
    """Retrieve an entitled bundle.


    :param entitled_bundle_id: The ID of the entitled bundle to retrieve (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundle_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Bundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve an entitled bundle.

:param entitled_bundle_id: The ID of the entitled bundle to retrieve (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundle_terms_of_use(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle of the terms of use to retrieve')]) ‑> TermsOfUse

Expand source code

@validate_call
def get_entitled_bundle_terms_of_use(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> TermsOfUse:
    """Retrieve the last version of terms of use for an entitled bundle.


    :param entitled_bundle_id: The ID of the entitled bundle of the terms of use to retrieve (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundle_terms_of_use_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUse",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the last version of terms of use for an entitled bundle.

:param entitled_bundle_id: The ID of the entitled bundle of the terms of use to retrieve (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundle_terms_of_use_acceptance(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle of the terms of use acceptance records.')]) ‑> TermsOfUseAcceptance

Expand source code

@validate_call
def get_entitled_bundle_terms_of_use_acceptance(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use acceptance records.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> TermsOfUseAcceptance:
    """Retrieve the acceptance record for an entitled bundle for the current user.


    :param entitled_bundle_id: The ID of the entitled bundle of the terms of use acceptance records. (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundle_terms_of_use_acceptance_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUseAcceptance",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the acceptance record for an entitled bundle for the current user.

:param entitled_bundle_id: The ID of the entitled bundle of the terms of use acceptance records. (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundle_terms_of_use_acceptance_with_http_info(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle of the terms of use acceptance records.')]) ‑> ApiResponse[TermsOfUseAcceptance]

Expand source code

@validate_call
def get_entitled_bundle_terms_of_use_acceptance_with_http_info(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use acceptance records.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[TermsOfUseAcceptance]:
    """Retrieve the acceptance record for an entitled bundle for the current user.


    :param entitled_bundle_id: The ID of the entitled bundle of the terms of use acceptance records. (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundle_terms_of_use_acceptance_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUseAcceptance",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the acceptance record for an entitled bundle for the current user.

:param entitled_bundle_id: The ID of the entitled bundle of the terms of use acceptance records. (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundle_terms_of_use_acceptance_without_preload_content(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle of the terms of use acceptance records.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_entitled_bundle_terms_of_use_acceptance_without_preload_content(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use acceptance records.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the acceptance record for an entitled bundle for the current user.


    :param entitled_bundle_id: The ID of the entitled bundle of the terms of use acceptance records. (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundle_terms_of_use_acceptance_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUseAcceptance",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the acceptance record for an entitled bundle for the current user.

:param entitled_bundle_id: The ID of the entitled bundle of the terms of use acceptance records. (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundle_terms_of_use_with_http_info(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle of the terms of use to retrieve')]) ‑> ApiResponse[TermsOfUse]

Expand source code

@validate_call
def get_entitled_bundle_terms_of_use_with_http_info(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[TermsOfUse]:
    """Retrieve the last version of terms of use for an entitled bundle.


    :param entitled_bundle_id: The ID of the entitled bundle of the terms of use to retrieve (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundle_terms_of_use_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUse",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the last version of terms of use for an entitled bundle.

:param entitled_bundle_id: The ID of the entitled bundle of the terms of use to retrieve (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundle_terms_of_use_without_preload_content(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle of the terms of use to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_entitled_bundle_terms_of_use_without_preload_content(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle of the terms of use to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the last version of terms of use for an entitled bundle.


    :param entitled_bundle_id: The ID of the entitled bundle of the terms of use to retrieve (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundle_terms_of_use_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TermsOfUse",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the last version of terms of use for an entitled bundle.

:param entitled_bundle_id: The ID of the entitled bundle of the terms of use to retrieve (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundle_with_http_info(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle to retrieve')]) ‑> ApiResponse[Bundle]

Expand source code

@validate_call
def get_entitled_bundle_with_http_info(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Bundle]:
    """Retrieve an entitled bundle.


    :param entitled_bundle_id: The ID of the entitled bundle to retrieve (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundle_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Bundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve an entitled bundle.

:param entitled_bundle_id: The ID of the entitled bundle to retrieve (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundle_without_preload_content(self,
entitled_bundle_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the entitled bundle to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_entitled_bundle_without_preload_content(
    self,
    entitled_bundle_id: Annotated[StrictStr, Field(description="The ID of the entitled bundle to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve an entitled bundle.


    :param entitled_bundle_id: The ID of the entitled bundle to retrieve (required)
    :type entitled_bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundle_serialize(
        entitled_bundle_id=entitled_bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Bundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve an entitled bundle.

:param entitled_bundle_id: The ID of the entitled bundle to retrieve (required) :type entitled_bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundles(self,
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='User tags to filter on')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Technical tags to filter on')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription')] = None) ‑> BundlePagedList

Expand source code

@validate_call
def get_entitled_bundles(
    self,
    search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BundlePagedList:
    """Retrieve a list of entitled bundles.


    :param search: Search
    :type search: str
    :param user_tags: User tags to filter on
    :type user_tags: str
    :param technical_tags: Technical tags to filter on
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundles_serialize(
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundlePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of entitled bundles.

:param search: Search :type search: str :param user_tags: User tags to filter on :type user_tags: str :param technical_tags: Technical tags to filter on :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundles_with_http_info(self,
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='User tags to filter on')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Technical tags to filter on')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription')] = None) ‑> ApiResponse[BundlePagedList]

Expand source code

@validate_call
def get_entitled_bundles_with_http_info(
    self,
    search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BundlePagedList]:
    """Retrieve a list of entitled bundles.


    :param search: Search
    :type search: str
    :param user_tags: User tags to filter on
    :type user_tags: str
    :param technical_tags: Technical tags to filter on
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundles_serialize(
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundlePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of entitled bundles.

:param search: Search :type search: str :param user_tags: User tags to filter on :type user_tags: str :param technical_tags: Technical tags to filter on :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_entitled_bundles_without_preload_content(self,
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='User tags to filter on')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Technical tags to filter on')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_entitled_bundles_without_preload_content(
    self,
    search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="User tags to filter on")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="Technical tags to filter on")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of entitled bundles.


    :param search: Search
    :type search: str
    :param user_tags: User tags to filter on
    :type user_tags: str
    :param technical_tags: Technical tags to filter on
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_entitled_bundles_serialize(
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BundlePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of entitled bundles.

:param search: Search :type search: str :param user_tags: User tags to filter on :type user_tags: str :param technical_tags: Technical tags to filter on :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class EntitlementDetailApi (api_client=None)

Expand source code

class EntitlementDetailApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def find_all_matching_activation_codes_for_cwl(
        self,
        search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ActivationCodeDetailList:
        """Search all matching activation code details for a Cwl pipeline.

        Endpoint for searching all matching activation code details for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_cwl_analysis: (required)
        :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_all_matching_activation_codes_for_cwl_serialize(
            search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetailList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def find_all_matching_activation_codes_for_cwl_with_http_info(
        self,
        search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ActivationCodeDetailList]:
        """Search all matching activation code details for a Cwl pipeline.

        Endpoint for searching all matching activation code details for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_cwl_analysis: (required)
        :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_all_matching_activation_codes_for_cwl_serialize(
            search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetailList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def find_all_matching_activation_codes_for_cwl_without_preload_content(
        self,
        search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Search all matching activation code details for a Cwl pipeline.

        Endpoint for searching all matching activation code details for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_cwl_analysis: (required)
        :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_all_matching_activation_codes_for_cwl_serialize(
            search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetailList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _find_all_matching_activation_codes_for_cwl_serialize(
        self,
        search_matching_activation_codes_for_cwl_analysis,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if search_matching_activation_codes_for_cwl_analysis is not None:
            _body_params = search_matching_activation_codes_for_cwl_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/activationCodes:findAllMatchingForCwl',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def find_all_matching_activation_codes_for_nextflow(
        self,
        search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ActivationCodeDetailList:
        """Search all matching activation code details for a Nextflow pipeline.

        Endpoint for searching all matching activation code details for a project and an analysis from a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_nextflow_analysis: (required)
        :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_all_matching_activation_codes_for_nextflow_serialize(
            search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetailList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def find_all_matching_activation_codes_for_nextflow_with_http_info(
        self,
        search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ActivationCodeDetailList]:
        """Search all matching activation code details for a Nextflow pipeline.

        Endpoint for searching all matching activation code details for a project and an analysis from a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_nextflow_analysis: (required)
        :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_all_matching_activation_codes_for_nextflow_serialize(
            search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetailList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def find_all_matching_activation_codes_for_nextflow_without_preload_content(
        self,
        search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Search all matching activation code details for a Nextflow pipeline.

        Endpoint for searching all matching activation code details for a project and an analysis from a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_nextflow_analysis: (required)
        :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_all_matching_activation_codes_for_nextflow_serialize(
            search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetailList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _find_all_matching_activation_codes_for_nextflow_serialize(
        self,
        search_matching_activation_codes_for_nextflow_analysis,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if search_matching_activation_codes_for_nextflow_analysis is not None:
            _body_params = search_matching_activation_codes_for_nextflow_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/activationCodes:findAllMatchingForNextflow',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def find_best_matching_activation_code_for_cwl(
        self,
        search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ActivationCodeDetail:
        """Search the best matching activation code detail for Cwl pipeline.

        Endpoint for searching the best activation code detail for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_cwl_analysis: (required)
        :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_best_matching_activation_code_for_cwl_serialize(
            search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetail",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def find_best_matching_activation_code_for_cwl_with_http_info(
        self,
        search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ActivationCodeDetail]:
        """Search the best matching activation code detail for Cwl pipeline.

        Endpoint for searching the best activation code detail for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_cwl_analysis: (required)
        :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_best_matching_activation_code_for_cwl_serialize(
            search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetail",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def find_best_matching_activation_code_for_cwl_without_preload_content(
        self,
        search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Search the best matching activation code detail for Cwl pipeline.

        Endpoint for searching the best activation code detail for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_cwl_analysis: (required)
        :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_best_matching_activation_code_for_cwl_serialize(
            search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetail",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _find_best_matching_activation_code_for_cwl_serialize(
        self,
        search_matching_activation_codes_for_cwl_analysis,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if search_matching_activation_codes_for_cwl_analysis is not None:
            _body_params = search_matching_activation_codes_for_cwl_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/activationCodes:findBestMatchingForCwl',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def find_best_matching_activation_codes_for_nextflow(
        self,
        search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ActivationCodeDetail:
        """Search the best matching activation code details for Nextflow pipeline.

        Endpoint for searching the best activation code details for a project and an analysis for a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_nextflow_analysis: (required)
        :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_best_matching_activation_codes_for_nextflow_serialize(
            search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetail",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def find_best_matching_activation_codes_for_nextflow_with_http_info(
        self,
        search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ActivationCodeDetail]:
        """Search the best matching activation code details for Nextflow pipeline.

        Endpoint for searching the best activation code details for a project and an analysis for a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_nextflow_analysis: (required)
        :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_best_matching_activation_codes_for_nextflow_serialize(
            search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetail",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def find_best_matching_activation_codes_for_nextflow_without_preload_content(
        self,
        search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Search the best matching activation code details for Nextflow pipeline.

        Endpoint for searching the best activation code details for a project and an analysis for a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param search_matching_activation_codes_for_nextflow_analysis: (required)
        :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._find_best_matching_activation_codes_for_nextflow_serialize(
            search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ActivationCodeDetail",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _find_best_matching_activation_codes_for_nextflow_serialize(
        self,
        search_matching_activation_codes_for_nextflow_analysis,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if search_matching_activation_codes_for_nextflow_analysis is not None:
            _body_params = search_matching_activation_codes_for_nextflow_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/activationCodes:findBestMatchingForNextflow',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def find_all_matching_activation_codes_for_cwl(self,
search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis) ‑> ActivationCodeDetailList

Expand source code

@validate_call
def find_all_matching_activation_codes_for_cwl(
    self,
    search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ActivationCodeDetailList:
    """Search all matching activation code details for a Cwl pipeline.

    Endpoint for searching all matching activation code details for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_cwl_analysis: (required)
    :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_all_matching_activation_codes_for_cwl_serialize(
        search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetailList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Search all matching activation code details for a Cwl pipeline.

Endpoint for searching all matching activation code details for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_cwl_analysis: (required) :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_all_matching_activation_codes_for_cwl_with_http_info(self,
search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis) ‑> ApiResponse[ActivationCodeDetailList]

Expand source code

@validate_call
def find_all_matching_activation_codes_for_cwl_with_http_info(
    self,
    search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ActivationCodeDetailList]:
    """Search all matching activation code details for a Cwl pipeline.

    Endpoint for searching all matching activation code details for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_cwl_analysis: (required)
    :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_all_matching_activation_codes_for_cwl_serialize(
        search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetailList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Search all matching activation code details for a Cwl pipeline.

Endpoint for searching all matching activation code details for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_cwl_analysis: (required) :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_all_matching_activation_codes_for_cwl_without_preload_content(self,
search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def find_all_matching_activation_codes_for_cwl_without_preload_content(
    self,
    search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Search all matching activation code details for a Cwl pipeline.

    Endpoint for searching all matching activation code details for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_cwl_analysis: (required)
    :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_all_matching_activation_codes_for_cwl_serialize(
        search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetailList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Search all matching activation code details for a Cwl pipeline.

Endpoint for searching all matching activation code details for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_cwl_analysis: (required) :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_all_matching_activation_codes_for_nextflow(self,
search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis) ‑> ActivationCodeDetailList

Expand source code

@validate_call
def find_all_matching_activation_codes_for_nextflow(
    self,
    search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ActivationCodeDetailList:
    """Search all matching activation code details for a Nextflow pipeline.

    Endpoint for searching all matching activation code details for a project and an analysis from a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_nextflow_analysis: (required)
    :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_all_matching_activation_codes_for_nextflow_serialize(
        search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetailList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Search all matching activation code details for a Nextflow pipeline.

Endpoint for searching all matching activation code details for a project and an analysis from a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_nextflow_analysis: (required) :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_all_matching_activation_codes_for_nextflow_with_http_info(self,
search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis) ‑> ApiResponse[ActivationCodeDetailList]

Expand source code

@validate_call
def find_all_matching_activation_codes_for_nextflow_with_http_info(
    self,
    search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ActivationCodeDetailList]:
    """Search all matching activation code details for a Nextflow pipeline.

    Endpoint for searching all matching activation code details for a project and an analysis from a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_nextflow_analysis: (required)
    :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_all_matching_activation_codes_for_nextflow_serialize(
        search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetailList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Search all matching activation code details for a Nextflow pipeline.

Endpoint for searching all matching activation code details for a project and an analysis from a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_nextflow_analysis: (required) :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_all_matching_activation_codes_for_nextflow_without_preload_content(self,
search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def find_all_matching_activation_codes_for_nextflow_without_preload_content(
    self,
    search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Search all matching activation code details for a Nextflow pipeline.

    Endpoint for searching all matching activation code details for a project and an analysis from a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_nextflow_analysis: (required)
    :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_all_matching_activation_codes_for_nextflow_serialize(
        search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetailList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Search all matching activation code details for a Nextflow pipeline.

Endpoint for searching all matching activation code details for a project and an analysis from a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_nextflow_analysis: (required) :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_best_matching_activation_code_for_cwl(self,
search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis) ‑> ActivationCodeDetail

Expand source code

@validate_call
def find_best_matching_activation_code_for_cwl(
    self,
    search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ActivationCodeDetail:
    """Search the best matching activation code detail for Cwl pipeline.

    Endpoint for searching the best activation code detail for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_cwl_analysis: (required)
    :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_best_matching_activation_code_for_cwl_serialize(
        search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetail",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Search the best matching activation code detail for Cwl pipeline.

Endpoint for searching the best activation code detail for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_cwl_analysis: (required) :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_best_matching_activation_code_for_cwl_with_http_info(self,
search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis) ‑> ApiResponse[ActivationCodeDetail]

Expand source code

@validate_call
def find_best_matching_activation_code_for_cwl_with_http_info(
    self,
    search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ActivationCodeDetail]:
    """Search the best matching activation code detail for Cwl pipeline.

    Endpoint for searching the best activation code detail for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_cwl_analysis: (required)
    :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_best_matching_activation_code_for_cwl_serialize(
        search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetail",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Search the best matching activation code detail for Cwl pipeline.

Endpoint for searching the best activation code detail for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_cwl_analysis: (required) :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_best_matching_activation_code_for_cwl_without_preload_content(self,
search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def find_best_matching_activation_code_for_cwl_without_preload_content(
    self,
    search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Search the best matching activation code detail for Cwl pipeline.

    Endpoint for searching the best activation code detail for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_cwl_analysis: (required)
    :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_best_matching_activation_code_for_cwl_serialize(
        search_matching_activation_codes_for_cwl_analysis=search_matching_activation_codes_for_cwl_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetail",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Search the best matching activation code detail for Cwl pipeline.

Endpoint for searching the best activation code detail for a project and an analysis from a Cwl pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_cwl_analysis: (required) :type search_matching_activation_codes_for_cwl_analysis: SearchMatchingActivationCodesForCwlAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_best_matching_activation_codes_for_nextflow(self,
search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis) ‑> ActivationCodeDetail

Expand source code

@validate_call
def find_best_matching_activation_codes_for_nextflow(
    self,
    search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ActivationCodeDetail:
    """Search the best matching activation code details for Nextflow pipeline.

    Endpoint for searching the best activation code details for a project and an analysis for a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_nextflow_analysis: (required)
    :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_best_matching_activation_codes_for_nextflow_serialize(
        search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetail",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Search the best matching activation code details for Nextflow pipeline.

Endpoint for searching the best activation code details for a project and an analysis for a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_nextflow_analysis: (required) :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_best_matching_activation_codes_for_nextflow_with_http_info(self,
search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis) ‑> ApiResponse[ActivationCodeDetail]

Expand source code

@validate_call
def find_best_matching_activation_codes_for_nextflow_with_http_info(
    self,
    search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ActivationCodeDetail]:
    """Search the best matching activation code details for Nextflow pipeline.

    Endpoint for searching the best activation code details for a project and an analysis for a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_nextflow_analysis: (required)
    :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_best_matching_activation_codes_for_nextflow_serialize(
        search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetail",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Search the best matching activation code details for Nextflow pipeline.

Endpoint for searching the best activation code details for a project and an analysis for a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_nextflow_analysis: (required) :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def find_best_matching_activation_codes_for_nextflow_without_preload_content(self,
search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def find_best_matching_activation_codes_for_nextflow_without_preload_content(
    self,
    search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Search the best matching activation code details for Nextflow pipeline.

    Endpoint for searching the best activation code details for a project and an analysis for a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param search_matching_activation_codes_for_nextflow_analysis: (required)
    :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._find_best_matching_activation_codes_for_nextflow_serialize(
        search_matching_activation_codes_for_nextflow_analysis=search_matching_activation_codes_for_nextflow_analysis,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ActivationCodeDetail",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Search the best matching activation code details for Nextflow pipeline.

Endpoint for searching the best activation code details for a project and an analysis for a Nextflow pipeline.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param search_matching_activation_codes_for_nextflow_analysis: (required) :type search_matching_activation_codes_for_nextflow_analysis: SearchMatchingActivationCodesForNextflowAnalysis :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class EventCode (**data: Any)

Expand source code

class EventCode(BaseModel):
    """
    EventCode
    """ # noqa: E501
    event_code: Annotated[str, Field(min_length=1, strict=True, max_length=20)] = Field(description="The event code that can be used for creating event subscriptions", alias="eventCode")
    description: Annotated[str, Field(min_length=1, strict=True, max_length=200)] = Field(description="A short description about the event code")
    __properties: ClassVar[List[str]] = ["eventCode", "description"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of EventCode from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of EventCode from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "eventCode": obj.get("eventCode"),
            "description": obj.get("description")
        })
        return _obj

EventCode

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str

The type of the None singleton.

var event_code : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of EventCode from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of EventCode from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class EventCodeApi (api_client=None)

Expand source code

class EventCodeApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_event_codes(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> EventCodeList:
        """Retrieve event codes


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_event_codes_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "EventCodeList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_event_codes_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[EventCodeList]:
        """Retrieve event codes


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_event_codes_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "EventCodeList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_event_codes_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve event codes


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_event_codes_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "EventCodeList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_event_codes_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/eventCodes',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_event_codes(self) ‑> EventCodeList

Expand source code

@validate_call
def get_event_codes(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> EventCodeList:
    """Retrieve event codes


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_event_codes_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "EventCodeList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve event codes

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_event_codes_with_http_info(self) ‑> ApiResponse[EventCodeList]

Expand source code

@validate_call
def get_event_codes_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[EventCodeList]:
    """Retrieve event codes


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_event_codes_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "EventCodeList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve event codes

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_event_codes_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_event_codes_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve event codes


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_event_codes_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "EventCodeList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve event codes

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class EventCodeList (**data: Any)

Expand source code

class EventCodeList(BaseModel):
    """
    EventCodeList
    """ # noqa: E501
    items: List[EventCode]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of EventCodeList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of EventCodeList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [EventCode.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

EventCodeList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[EventCode]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of EventCodeList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of EventCodeList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class EventLogApi (api_client=None)

Expand source code

class EventLogApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_event_logs(
        self,
        code: Annotated[Optional[StrictStr], Field(description="Code")] = None,
        code_filter_type: Annotated[Optional[StrictStr], Field(description="Code filter type")] = None,
        category: Annotated[Optional[StrictStr], Field(description="Category")] = None,
        date_from: Annotated[Optional[StrictStr], Field(description="Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
        date_until: Annotated[Optional[StrictStr], Field(description="Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
        rows: Annotated[Optional[StrictInt], Field(description="Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> EventLogListV3:
        """(Deprecated) Retrieve a list of event logs.


        :param code: Code
        :type code: str
        :param code_filter_type: Code filter type
        :type code_filter_type: str
        :param category: Category
        :type category: str
        :param date_from: Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
        :type date_from: str
        :param date_until: Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
        :type date_until: str
        :param rows: Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250
        :type rows: int
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/eventLog is deprecated.", DeprecationWarning)

        _param = self._get_event_logs_serialize(
            code=code,
            code_filter_type=code_filter_type,
            category=category,
            date_from=date_from,
            date_until=date_until,
            rows=rows,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "EventLogListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_event_logs_with_http_info(
        self,
        code: Annotated[Optional[StrictStr], Field(description="Code")] = None,
        code_filter_type: Annotated[Optional[StrictStr], Field(description="Code filter type")] = None,
        category: Annotated[Optional[StrictStr], Field(description="Category")] = None,
        date_from: Annotated[Optional[StrictStr], Field(description="Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
        date_until: Annotated[Optional[StrictStr], Field(description="Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
        rows: Annotated[Optional[StrictInt], Field(description="Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[EventLogListV3]:
        """(Deprecated) Retrieve a list of event logs.


        :param code: Code
        :type code: str
        :param code_filter_type: Code filter type
        :type code_filter_type: str
        :param category: Category
        :type category: str
        :param date_from: Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
        :type date_from: str
        :param date_until: Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
        :type date_until: str
        :param rows: Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250
        :type rows: int
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/eventLog is deprecated.", DeprecationWarning)

        _param = self._get_event_logs_serialize(
            code=code,
            code_filter_type=code_filter_type,
            category=category,
            date_from=date_from,
            date_until=date_until,
            rows=rows,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "EventLogListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_event_logs_without_preload_content(
        self,
        code: Annotated[Optional[StrictStr], Field(description="Code")] = None,
        code_filter_type: Annotated[Optional[StrictStr], Field(description="Code filter type")] = None,
        category: Annotated[Optional[StrictStr], Field(description="Category")] = None,
        date_from: Annotated[Optional[StrictStr], Field(description="Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
        date_until: Annotated[Optional[StrictStr], Field(description="Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
        rows: Annotated[Optional[StrictInt], Field(description="Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """(Deprecated) Retrieve a list of event logs.


        :param code: Code
        :type code: str
        :param code_filter_type: Code filter type
        :type code_filter_type: str
        :param category: Category
        :type category: str
        :param date_from: Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
        :type date_from: str
        :param date_until: Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
        :type date_until: str
        :param rows: Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250
        :type rows: int
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/eventLog is deprecated.", DeprecationWarning)

        _param = self._get_event_logs_serialize(
            code=code,
            code_filter_type=code_filter_type,
            category=category,
            date_from=date_from,
            date_until=date_until,
            rows=rows,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "EventLogListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_event_logs_serialize(
        self,
        code,
        code_filter_type,
        category,
        date_from,
        date_until,
        rows,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if code is not None:
            
            _query_params.append(('code', code))
            
        if code_filter_type is not None:
            
            _query_params.append(('codeFilterType', code_filter_type))
            
        if category is not None:
            
            _query_params.append(('category', category))
            
        if date_from is not None:
            
            _query_params.append(('dateFrom', date_from))
            
        if date_until is not None:
            
            _query_params.append(('dateUntil', date_until))
            
        if rows is not None:
            
            _query_params.append(('rows', rows))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/eventLog',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def search_event_logs(
        self,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated ")] = None,
        event_log_query_parameters_v4: Optional[EventLogQueryParametersV4] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> EventLogPagedListV4:
        """Search event logs.


        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated 
        :type sort: str
        :param event_log_query_parameters_v4:
        :type event_log_query_parameters_v4: EventLogQueryParametersV4
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_event_logs_serialize(
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            event_log_query_parameters_v4=event_log_query_parameters_v4,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "EventLogPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def search_event_logs_with_http_info(
        self,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated ")] = None,
        event_log_query_parameters_v4: Optional[EventLogQueryParametersV4] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[EventLogPagedListV4]:
        """Search event logs.


        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated 
        :type sort: str
        :param event_log_query_parameters_v4:
        :type event_log_query_parameters_v4: EventLogQueryParametersV4
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_event_logs_serialize(
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            event_log_query_parameters_v4=event_log_query_parameters_v4,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "EventLogPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def search_event_logs_without_preload_content(
        self,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated ")] = None,
        event_log_query_parameters_v4: Optional[EventLogQueryParametersV4] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Search event logs.


        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated 
        :type sort: str
        :param event_log_query_parameters_v4:
        :type event_log_query_parameters_v4: EventLogQueryParametersV4
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_event_logs_serialize(
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            event_log_query_parameters_v4=event_log_query_parameters_v4,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "EventLogPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _search_event_logs_serialize(
        self,
        page_offset,
        page_token,
        page_size,
        sort,
        event_log_query_parameters_v4,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if event_log_query_parameters_v4 is not None:
            _body_params = event_log_query_parameters_v4


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/eventLog:search',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_event_logs(self,
code: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Code')] = None,
code_filter_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Code filter type')] = None,
category: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Category')] = None,
date_from: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
date_until: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
rows: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250')] = None) ‑> EventLogListV3

Expand source code

@validate_call
def get_event_logs(
    self,
    code: Annotated[Optional[StrictStr], Field(description="Code")] = None,
    code_filter_type: Annotated[Optional[StrictStr], Field(description="Code filter type")] = None,
    category: Annotated[Optional[StrictStr], Field(description="Category")] = None,
    date_from: Annotated[Optional[StrictStr], Field(description="Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
    date_until: Annotated[Optional[StrictStr], Field(description="Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
    rows: Annotated[Optional[StrictInt], Field(description="Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> EventLogListV3:
    """(Deprecated) Retrieve a list of event logs.


    :param code: Code
    :type code: str
    :param code_filter_type: Code filter type
    :type code_filter_type: str
    :param category: Category
    :type category: str
    :param date_from: Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
    :type date_from: str
    :param date_until: Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
    :type date_until: str
    :param rows: Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250
    :type rows: int
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/eventLog is deprecated.", DeprecationWarning)

    _param = self._get_event_logs_serialize(
        code=code,
        code_filter_type=code_filter_type,
        category=category,
        date_from=date_from,
        date_until=date_until,
        rows=rows,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "EventLogListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

(Deprecated) Retrieve a list of event logs.

:param code: Code :type code: str :param code_filter_type: Code filter type :type code_filter_type: str :param category: Category :type category: str :param date_from: Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z :type date_from: str :param date_until: Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z :type date_until: str :param rows: Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250 :type rows: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_event_logs_with_http_info(self,
code: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Code')] = None,
code_filter_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Code filter type')] = None,
category: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Category')] = None,
date_from: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
date_until: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
rows: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250')] = None) ‑> ApiResponse[EventLogListV3]

Expand source code

@validate_call
def get_event_logs_with_http_info(
    self,
    code: Annotated[Optional[StrictStr], Field(description="Code")] = None,
    code_filter_type: Annotated[Optional[StrictStr], Field(description="Code filter type")] = None,
    category: Annotated[Optional[StrictStr], Field(description="Category")] = None,
    date_from: Annotated[Optional[StrictStr], Field(description="Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
    date_until: Annotated[Optional[StrictStr], Field(description="Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
    rows: Annotated[Optional[StrictInt], Field(description="Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[EventLogListV3]:
    """(Deprecated) Retrieve a list of event logs.


    :param code: Code
    :type code: str
    :param code_filter_type: Code filter type
    :type code_filter_type: str
    :param category: Category
    :type category: str
    :param date_from: Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
    :type date_from: str
    :param date_until: Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
    :type date_until: str
    :param rows: Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250
    :type rows: int
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/eventLog is deprecated.", DeprecationWarning)

    _param = self._get_event_logs_serialize(
        code=code,
        code_filter_type=code_filter_type,
        category=category,
        date_from=date_from,
        date_until=date_until,
        rows=rows,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "EventLogListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

(Deprecated) Retrieve a list of event logs.

:param code: Code :type code: str :param code_filter_type: Code filter type :type code_filter_type: str :param category: Category :type category: str :param date_from: Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z :type date_from: str :param date_until: Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z :type date_until: str :param rows: Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250 :type rows: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_event_logs_without_preload_content(self,
code: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Code')] = None,
code_filter_type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Code filter type')] = None,
category: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Category')] = None,
date_from: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
date_until: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
rows: Annotated[Annotated[int, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_event_logs_without_preload_content(
    self,
    code: Annotated[Optional[StrictStr], Field(description="Code")] = None,
    code_filter_type: Annotated[Optional[StrictStr], Field(description="Code filter type")] = None,
    category: Annotated[Optional[StrictStr], Field(description="Category")] = None,
    date_from: Annotated[Optional[StrictStr], Field(description="Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
    date_until: Annotated[Optional[StrictStr], Field(description="Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z")] = None,
    rows: Annotated[Optional[StrictInt], Field(description="Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Retrieve a list of event logs.


    :param code: Code
    :type code: str
    :param code_filter_type: Code filter type
    :type code_filter_type: str
    :param category: Category
    :type category: str
    :param date_from: Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
    :type date_from: str
    :param date_until: Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z
    :type date_until: str
    :param rows: Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250
    :type rows: int
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/eventLog is deprecated.", DeprecationWarning)

    _param = self._get_event_logs_serialize(
        code=code,
        code_filter_type=code_filter_type,
        category=category,
        date_from=date_from,
        date_until=date_until,
        rows=rows,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "EventLogListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

(Deprecated) Retrieve a list of event logs.

:param code: Code :type code: str :param code_filter_type: Code filter type :type code_filter_type: str :param category: Category :type category: str :param date_from: Date from. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z :type date_from: str :param date_until: Date until. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z :type date_until: str :param rows: Amount of rows to fetch (chronologically oldest first). Maximum 250. Defaults to 250 :type rows: int :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_event_logs(self,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated ')] = None,
event_log_query_parameters_v4: EventLogQueryParametersV4 | None = None) ‑> EventLogPagedListV4

Expand source code

@validate_call
def search_event_logs(
    self,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated ")] = None,
    event_log_query_parameters_v4: Optional[EventLogQueryParametersV4] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> EventLogPagedListV4:
    """Search event logs.


    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated 
    :type sort: str
    :param event_log_query_parameters_v4:
    :type event_log_query_parameters_v4: EventLogQueryParametersV4
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_event_logs_serialize(
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        event_log_query_parameters_v4=event_log_query_parameters_v4,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "EventLogPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Search event logs.

:param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated :type sort: str :param event_log_query_parameters_v4: :type event_log_query_parameters_v4: EventLogQueryParametersV4 :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_event_logs_with_http_info(self,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated ')] = None,
event_log_query_parameters_v4: EventLogQueryParametersV4 | None = None) ‑> ApiResponse[EventLogPagedListV4]

Expand source code

@validate_call
def search_event_logs_with_http_info(
    self,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated ")] = None,
    event_log_query_parameters_v4: Optional[EventLogQueryParametersV4] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[EventLogPagedListV4]:
    """Search event logs.


    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated 
    :type sort: str
    :param event_log_query_parameters_v4:
    :type event_log_query_parameters_v4: EventLogQueryParametersV4
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_event_logs_serialize(
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        event_log_query_parameters_v4=event_log_query_parameters_v4,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "EventLogPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Search event logs.

:param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated :type sort: str :param event_log_query_parameters_v4: :type event_log_query_parameters_v4: EventLogQueryParametersV4 :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_event_logs_without_preload_content(self,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated ')] = None,
event_log_query_parameters_v4: EventLogQueryParametersV4 | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def search_event_logs_without_preload_content(
    self,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated ")] = None,
    event_log_query_parameters_v4: Optional[EventLogQueryParametersV4] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Search event logs.


    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated 
    :type sort: str
    :param event_log_query_parameters_v4:
    :type event_log_query_parameters_v4: EventLogQueryParametersV4
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_event_logs_serialize(
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        event_log_query_parameters_v4=event_log_query_parameters_v4,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "EventLogPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Search event logs.

:param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated :type sort: str :param event_log_query_parameters_v4: :type event_log_query_parameters_v4: EventLogQueryParametersV4 :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class EventLogListV3 (**data: Any)

Expand source code

class EventLogListV3(BaseModel):
    """
    EventLogListV3
    """ # noqa: E501
    items: List[EventLogV3]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of EventLogListV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of EventLogListV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [EventLogV3.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

EventLogListV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[EventLogV3]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of EventLogListV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of EventLogListV3 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class EventLogPagedListV4 (**data: Any)

Expand source code

class EventLogPagedListV4(BaseModel):
    """
    EventLogPagedListV4
    """ # noqa: E501
    items: List[EventLogV4]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of EventLogPagedListV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of EventLogPagedListV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [EventLogV4.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

EventLogPagedListV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[EventLogV4]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of EventLogPagedListV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of EventLogPagedListV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class EventLogQueryParametersV4 (**data: Any)

Expand source code

class EventLogQueryParametersV4(BaseModel):
    """
    EventLogQueryParametersV4
    """ # noqa: E501
    code: Optional[StrictStr] = Field(default=None, description="The code to filter on.")
    category: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="The category to filter on")
    date_from: Optional[datetime] = Field(default=None, description="The date from to search in.", alias="dateFrom")
    date_until: Optional[datetime] = Field(default=None, description="The date until to search in.", alias="dateUntil")
    __properties: ClassVar[List[str]] = ["code", "category", "dateFrom", "dateUntil"]

    @field_validator('category')
    def category_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if value is None:
            return value

        if not re.match(r"ERROR|WARN|INFO", value):
            raise ValueError(r"must validate the regular expression /ERROR|WARN|INFO/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of EventLogQueryParametersV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if code (nullable) is None
        # and model_fields_set contains the field
        if self.code is None and "code" in self.model_fields_set:
            _dict['code'] = None

        # set to None if category (nullable) is None
        # and model_fields_set contains the field
        if self.category is None and "category" in self.model_fields_set:
            _dict['category'] = None

        # set to None if date_from (nullable) is None
        # and model_fields_set contains the field
        if self.date_from is None and "date_from" in self.model_fields_set:
            _dict['dateFrom'] = None

        # set to None if date_until (nullable) is None
        # and model_fields_set contains the field
        if self.date_until is None and "date_until" in self.model_fields_set:
            _dict['dateUntil'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of EventLogQueryParametersV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "category": obj.get("category"),
            "dateFrom": obj.get("dateFrom"),
            "dateUntil": obj.get("dateUntil")
        })
        return _obj

EventLogQueryParametersV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var category : str | None

The type of the None singleton.

var code : str | None

The type of the None singleton.

var date_from : datetime.datetime | None

The type of the None singleton.

var date_until : datetime.datetime | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def category_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of EventLogQueryParametersV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of EventLogQueryParametersV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if code (nullable) is None
    # and model_fields_set contains the field
    if self.code is None and "code" in self.model_fields_set:
        _dict['code'] = None

    # set to None if category (nullable) is None
    # and model_fields_set contains the field
    if self.category is None and "category" in self.model_fields_set:
        _dict['category'] = None

    # set to None if date_from (nullable) is None
    # and model_fields_set contains the field
    if self.date_from is None and "date_from" in self.model_fields_set:
        _dict['dateFrom'] = None

    # set to None if date_until (nullable) is None
    # and model_fields_set contains the field
    if self.date_until is None and "date_until" in self.model_fields_set:
        _dict['dateUntil'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class EventLogV3 (**data: Any)

Expand source code

class EventLogV3(BaseModel):
    """
    EventLogV3
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The code of the event")
    description: Annotated[str, Field(min_length=1, strict=True, max_length=1000)] = Field(description="The details of the event")
    event_type_category: StrictStr = Field(description="The type of the event", alias="eventTypeCategory")
    user_id: StrictStr = Field(alias="userId")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "code", "description", "eventTypeCategory", "userId"]

    @field_validator('event_type_category')
    def event_type_category_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['ERROR', 'WARN', 'INFO']):
            raise ValueError("must be one of enum values ('ERROR', 'WARN', 'INFO')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of EventLogV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of EventLogV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "code": obj.get("code"),
            "description": obj.get("description"),
            "eventTypeCategory": obj.get("eventTypeCategory"),
            "userId": obj.get("userId")
        })
        return _obj

EventLogV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str

The type of the None singleton.

var description : str

The type of the None singleton.

var event_type_category : str

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var user_id : str

The type of the None singleton.

Static methods

def event_type_category_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of EventLogV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of EventLogV3 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class EventLogV4 (**data: Any)

Expand source code

class EventLogV4(BaseModel):
    """
    EventLogV4
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    owner: UserIdentifier
    tenant: TenantIdentifier
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The code of the event")
    description: Annotated[str, Field(min_length=1, strict=True, max_length=1000)] = Field(description="The details of the event")
    event_type_category: Annotated[str, Field(strict=True)] = Field(description="The type of the event", alias="eventTypeCategory")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "owner", "tenant", "code", "description", "eventTypeCategory"]

    @field_validator('event_type_category')
    def event_type_category_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"ERROR|WARN|INFO", value):
            raise ValueError(r"must validate the regular expression /ERROR|WARN|INFO/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of EventLogV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of owner
        if self.owner:
            _dict['owner'] = self.owner.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tenant
        if self.tenant:
            _dict['tenant'] = self.tenant.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of EventLogV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "owner": UserIdentifier.from_dict(obj["owner"]) if obj.get("owner") is not None else None,
            "tenant": TenantIdentifier.from_dict(obj["tenant"]) if obj.get("tenant") is not None else None,
            "code": obj.get("code"),
            "description": obj.get("description"),
            "eventTypeCategory": obj.get("eventTypeCategory")
        })
        return _obj

EventLogV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str

The type of the None singleton.

var description : str

The type of the None singleton.

var event_type_category : str

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner : UserIdentifier

The type of the None singleton.

var tenant : TenantIdentifier

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

Static methods

def event_type_category_validate_regular_expression(value)

Validates the regular expression

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of EventLogV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of EventLogV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of owner
    if self.owner:
        _dict['owner'] = self.owner.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tenant
    if self.tenant:
        _dict['tenant'] = self.tenant.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ExecutionConfiguration (**data: Any)

Expand source code

class ExecutionConfiguration(BaseModel):
    """
    ExecutionConfiguration
    """ # noqa: E501
    name: StrictStr = Field(description="The name of the configuration")
    multi_value: StrictBool = Field(description="Whether the configuration has multiple values", alias="multiValue")
    values: List[StrictStr] = Field(description="The configuration values")
    __properties: ClassVar[List[str]] = ["name", "multiValue", "values"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ExecutionConfiguration from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ExecutionConfiguration from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "multiValue": obj.get("multiValue"),
            "values": obj.get("values")
        })
        return _obj

ExecutionConfiguration

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var multi_value : bool

The type of the None singleton.

var name : str

The type of the None singleton.

var values : List[str]

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ExecutionConfiguration from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ExecutionConfiguration from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ExecutionConfigurationList (**data: Any)

Expand source code

class ExecutionConfigurationList(BaseModel):
    """
    ExecutionConfigurationList
    """ # noqa: E501
    items: List[ExecutionConfiguration]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ExecutionConfigurationList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ExecutionConfigurationList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ExecutionConfiguration.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ExecutionConfigurationList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ExecutionConfiguration]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ExecutionConfigurationList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ExecutionConfigurationList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ExternalDockerImageSettings (**data: Any)

Expand source code

class ExternalDockerImageSettings(BaseModel):
    """
    ExternalDockerImageSettings
    """ # noqa: E501
    url: StrictStr
    __properties: ClassVar[List[str]] = ["url"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ExternalDockerImageSettings from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ExternalDockerImageSettings from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "url": obj.get("url")
        })
        return _obj

ExternalDockerImageSettings

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ExternalDockerImageSettings from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ExternalDockerImageSettings from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class FieldId (**data: Any)

Expand source code

class FieldId(BaseModel):
    """
    FieldId
    """ # noqa: E501
    id: StrictStr
    __properties: ClassVar[List[str]] = ["id"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of FieldId from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of FieldId from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id")
        })
        return _obj

FieldId

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of FieldId from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of FieldId from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class FieldList (**data: Any)

Expand source code

class FieldList(BaseModel):
    """
    FieldList
    """ # noqa: E501
    items: List[Optional[ModelField]]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of FieldList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of FieldList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ModelField.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

FieldList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ModelField | None]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of FieldList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of FieldList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class FindProjectSamples (**data: Any)

Expand source code

class FindProjectSamples(BaseModel):
    """
    FindProjectSamples
    """ # noqa: E501
    conditions: List[FindSampleCondition] = Field(description="Adds a condition on a string field.")
    date_conditions: List[FindSampleDateCondition] = Field(description="Adds a condition on a date metadate field. If both the dateBefore and dateAfter parameter are null it will return any sample that has no value for the date field.", alias="dateConditions")
    number_conditions: List[FindSampleNumberCondition] = Field(description="Adds a condition on a number metadata field. If both the lowerBoundary and upperBoundary parameter are null it will return any sample that has no value for the number field.", alias="numberConditions")
    boolean_conditions: List[FindSampleBooleanCondition] = Field(description="Adds a condition on a boolean field.", alias="booleanConditions")
    full_text_search_string: Optional[StrictStr] = Field(default=None, description="Adds a fuzzy matching condition for the text on all string fields of the sample i.e. on both the fixed fields (name, description) as any metadata text field.", alias="fullTextSearchString")
    include_deleted: Optional[StrictBool] = Field(default=False, description="Indicates whether deleted samples should be included.", alias="includeDeleted")
    user_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.", alias="userTags")
    user_tag_match_mode: Optional[StrictStr] = Field(default=None, description="How the usertags are filtered.", alias="userTagMatchMode")
    run_input_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.", alias="runInputTags")
    run_input_tag_match_mode: Optional[StrictStr] = Field(default=None, description="How the runInputTags are filtered.", alias="runInputTagMatchMode")
    connector_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.", alias="connectorTags")
    connector_tag_match_mode: Optional[StrictStr] = Field(default=None, description="How the connectorTags are filtered.", alias="connectorTagMatchMode")
    tech_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.", alias="techTags")
    tech_tag_match_mode: Optional[StrictStr] = Field(default=None, description="How the technicalTags are filtered.", alias="techTagMatchMode")
    instrument_run_ids: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="instrumentRunIds")
    __properties: ClassVar[List[str]] = ["conditions", "dateConditions", "numberConditions", "booleanConditions", "fullTextSearchString", "includeDeleted", "userTags", "userTagMatchMode", "runInputTags", "runInputTagMatchMode", "connectorTags", "connectorTagMatchMode", "techTags", "techTagMatchMode", "instrumentRunIds"]

    @field_validator('user_tag_match_mode')
    def user_tag_match_mode_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['EXACT', 'EXCLUDE', 'FUZZY']):
            raise ValueError("must be one of enum values ('EXACT', 'EXCLUDE', 'FUZZY')")
        return value

    @field_validator('run_input_tag_match_mode')
    def run_input_tag_match_mode_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['EXACT', 'EXCLUDE', 'FUZZY']):
            raise ValueError("must be one of enum values ('EXACT', 'EXCLUDE', 'FUZZY')")
        return value

    @field_validator('connector_tag_match_mode')
    def connector_tag_match_mode_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['EXACT', 'EXCLUDE', 'FUZZY']):
            raise ValueError("must be one of enum values ('EXACT', 'EXCLUDE', 'FUZZY')")
        return value

    @field_validator('tech_tag_match_mode')
    def tech_tag_match_mode_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['EXACT', 'EXCLUDE', 'FUZZY']):
            raise ValueError("must be one of enum values ('EXACT', 'EXCLUDE', 'FUZZY')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of FindProjectSamples from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in conditions (list)
        _items = []
        if self.conditions:
            for _item_conditions in self.conditions:
                if _item_conditions:
                    _items.append(_item_conditions.to_dict())
            _dict['conditions'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in date_conditions (list)
        _items = []
        if self.date_conditions:
            for _item_date_conditions in self.date_conditions:
                if _item_date_conditions:
                    _items.append(_item_date_conditions.to_dict())
            _dict['dateConditions'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in number_conditions (list)
        _items = []
        if self.number_conditions:
            for _item_number_conditions in self.number_conditions:
                if _item_number_conditions:
                    _items.append(_item_number_conditions.to_dict())
            _dict['numberConditions'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in boolean_conditions (list)
        _items = []
        if self.boolean_conditions:
            for _item_boolean_conditions in self.boolean_conditions:
                if _item_boolean_conditions:
                    _items.append(_item_boolean_conditions.to_dict())
            _dict['booleanConditions'] = _items
        # set to None if full_text_search_string (nullable) is None
        # and model_fields_set contains the field
        if self.full_text_search_string is None and "full_text_search_string" in self.model_fields_set:
            _dict['fullTextSearchString'] = None

        # set to None if include_deleted (nullable) is None
        # and model_fields_set contains the field
        if self.include_deleted is None and "include_deleted" in self.model_fields_set:
            _dict['includeDeleted'] = None

        # set to None if user_tags (nullable) is None
        # and model_fields_set contains the field
        if self.user_tags is None and "user_tags" in self.model_fields_set:
            _dict['userTags'] = None

        # set to None if user_tag_match_mode (nullable) is None
        # and model_fields_set contains the field
        if self.user_tag_match_mode is None and "user_tag_match_mode" in self.model_fields_set:
            _dict['userTagMatchMode'] = None

        # set to None if run_input_tags (nullable) is None
        # and model_fields_set contains the field
        if self.run_input_tags is None and "run_input_tags" in self.model_fields_set:
            _dict['runInputTags'] = None

        # set to None if run_input_tag_match_mode (nullable) is None
        # and model_fields_set contains the field
        if self.run_input_tag_match_mode is None and "run_input_tag_match_mode" in self.model_fields_set:
            _dict['runInputTagMatchMode'] = None

        # set to None if connector_tags (nullable) is None
        # and model_fields_set contains the field
        if self.connector_tags is None and "connector_tags" in self.model_fields_set:
            _dict['connectorTags'] = None

        # set to None if connector_tag_match_mode (nullable) is None
        # and model_fields_set contains the field
        if self.connector_tag_match_mode is None and "connector_tag_match_mode" in self.model_fields_set:
            _dict['connectorTagMatchMode'] = None

        # set to None if tech_tags (nullable) is None
        # and model_fields_set contains the field
        if self.tech_tags is None and "tech_tags" in self.model_fields_set:
            _dict['techTags'] = None

        # set to None if tech_tag_match_mode (nullable) is None
        # and model_fields_set contains the field
        if self.tech_tag_match_mode is None and "tech_tag_match_mode" in self.model_fields_set:
            _dict['techTagMatchMode'] = None

        # set to None if instrument_run_ids (nullable) is None
        # and model_fields_set contains the field
        if self.instrument_run_ids is None and "instrument_run_ids" in self.model_fields_set:
            _dict['instrumentRunIds'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of FindProjectSamples from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "conditions": [FindSampleCondition.from_dict(_item) for _item in obj["conditions"]] if obj.get("conditions") is not None else None,
            "dateConditions": [FindSampleDateCondition.from_dict(_item) for _item in obj["dateConditions"]] if obj.get("dateConditions") is not None else None,
            "numberConditions": [FindSampleNumberCondition.from_dict(_item) for _item in obj["numberConditions"]] if obj.get("numberConditions") is not None else None,
            "booleanConditions": [FindSampleBooleanCondition.from_dict(_item) for _item in obj["booleanConditions"]] if obj.get("booleanConditions") is not None else None,
            "fullTextSearchString": obj.get("fullTextSearchString"),
            "includeDeleted": obj.get("includeDeleted") if obj.get("includeDeleted") is not None else False,
            "userTags": obj.get("userTags"),
            "userTagMatchMode": obj.get("userTagMatchMode"),
            "runInputTags": obj.get("runInputTags"),
            "runInputTagMatchMode": obj.get("runInputTagMatchMode"),
            "connectorTags": obj.get("connectorTags"),
            "connectorTagMatchMode": obj.get("connectorTagMatchMode"),
            "techTags": obj.get("techTags"),
            "techTagMatchMode": obj.get("techTagMatchMode"),
            "instrumentRunIds": obj.get("instrumentRunIds")
        })
        return _obj

FindProjectSamples

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var boolean_conditions : List[FindSampleBooleanCondition]

The type of the None singleton.

var conditions : List[FindSampleCondition]

The type of the None singleton.

var connector_tag_match_mode : str | None

The type of the None singleton.

var connector_tags : List[str | None] | None

The type of the None singleton.

var date_conditions : List[FindSampleDateCondition]

The type of the None singleton.

var full_text_search_string : str | None

The type of the None singleton.

var include_deleted : bool | None

The type of the None singleton.

var instrument_run_ids : List[str | None] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var number_conditions : List[FindSampleNumberCondition]

The type of the None singleton.

var run_input_tag_match_mode : str | None

The type of the None singleton.

var run_input_tags : List[str | None] | None

The type of the None singleton.

var tech_tag_match_mode : str | None

The type of the None singleton.

var tech_tags : List[str | None] | None

The type of the None singleton.

var user_tag_match_mode : str | None

The type of the None singleton.

var user_tags : List[str | None] | None

The type of the None singleton.

Static methods

def connector_tag_match_mode_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of FindProjectSamples from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of FindProjectSamples from a JSON string

def run_input_tag_match_mode_validate_enum(value)

Validates the enum

def tech_tag_match_mode_validate_enum(value)

Validates the enum

def user_tag_match_mode_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in conditions (list)
    _items = []
    if self.conditions:
        for _item_conditions in self.conditions:
            if _item_conditions:
                _items.append(_item_conditions.to_dict())
        _dict['conditions'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in date_conditions (list)
    _items = []
    if self.date_conditions:
        for _item_date_conditions in self.date_conditions:
            if _item_date_conditions:
                _items.append(_item_date_conditions.to_dict())
        _dict['dateConditions'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in number_conditions (list)
    _items = []
    if self.number_conditions:
        for _item_number_conditions in self.number_conditions:
            if _item_number_conditions:
                _items.append(_item_number_conditions.to_dict())
        _dict['numberConditions'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in boolean_conditions (list)
    _items = []
    if self.boolean_conditions:
        for _item_boolean_conditions in self.boolean_conditions:
            if _item_boolean_conditions:
                _items.append(_item_boolean_conditions.to_dict())
        _dict['booleanConditions'] = _items
    # set to None if full_text_search_string (nullable) is None
    # and model_fields_set contains the field
    if self.full_text_search_string is None and "full_text_search_string" in self.model_fields_set:
        _dict['fullTextSearchString'] = None

    # set to None if include_deleted (nullable) is None
    # and model_fields_set contains the field
    if self.include_deleted is None and "include_deleted" in self.model_fields_set:
        _dict['includeDeleted'] = None

    # set to None if user_tags (nullable) is None
    # and model_fields_set contains the field
    if self.user_tags is None and "user_tags" in self.model_fields_set:
        _dict['userTags'] = None

    # set to None if user_tag_match_mode (nullable) is None
    # and model_fields_set contains the field
    if self.user_tag_match_mode is None and "user_tag_match_mode" in self.model_fields_set:
        _dict['userTagMatchMode'] = None

    # set to None if run_input_tags (nullable) is None
    # and model_fields_set contains the field
    if self.run_input_tags is None and "run_input_tags" in self.model_fields_set:
        _dict['runInputTags'] = None

    # set to None if run_input_tag_match_mode (nullable) is None
    # and model_fields_set contains the field
    if self.run_input_tag_match_mode is None and "run_input_tag_match_mode" in self.model_fields_set:
        _dict['runInputTagMatchMode'] = None

    # set to None if connector_tags (nullable) is None
    # and model_fields_set contains the field
    if self.connector_tags is None and "connector_tags" in self.model_fields_set:
        _dict['connectorTags'] = None

    # set to None if connector_tag_match_mode (nullable) is None
    # and model_fields_set contains the field
    if self.connector_tag_match_mode is None and "connector_tag_match_mode" in self.model_fields_set:
        _dict['connectorTagMatchMode'] = None

    # set to None if tech_tags (nullable) is None
    # and model_fields_set contains the field
    if self.tech_tags is None and "tech_tags" in self.model_fields_set:
        _dict['techTags'] = None

    # set to None if tech_tag_match_mode (nullable) is None
    # and model_fields_set contains the field
    if self.tech_tag_match_mode is None and "tech_tag_match_mode" in self.model_fields_set:
        _dict['techTagMatchMode'] = None

    # set to None if instrument_run_ids (nullable) is None
    # and model_fields_set contains the field
    if self.instrument_run_ids is None and "instrument_run_ids" in self.model_fields_set:
        _dict['instrumentRunIds'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class FindSampleBooleanCondition (**data: Any)

Expand source code

class FindSampleBooleanCondition(BaseModel):
    """
    Adds a condition on a boolean field.
    """ # noqa: E501
    metadata_field: Optional[ModelField] = Field(default=None, alias="metadataField")
    var_field: Optional[StrictStr] = Field(default=None, alias="field")
    value: Optional[StrictStr] = None
    __properties: ClassVar[List[str]] = ["metadataField", "field", "value"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of FindSampleBooleanCondition from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of metadata_field
        if self.metadata_field:
            _dict['metadataField'] = self.metadata_field.to_dict()
        # set to None if metadata_field (nullable) is None
        # and model_fields_set contains the field
        if self.metadata_field is None and "metadata_field" in self.model_fields_set:
            _dict['metadataField'] = None

        # set to None if var_field (nullable) is None
        # and model_fields_set contains the field
        if self.var_field is None and "var_field" in self.model_fields_set:
            _dict['field'] = None

        # set to None if value (nullable) is None
        # and model_fields_set contains the field
        if self.value is None and "value" in self.model_fields_set:
            _dict['value'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of FindSampleBooleanCondition from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "metadataField": ModelField.from_dict(obj["metadataField"]) if obj.get("metadataField") is not None else None,
            "field": obj.get("field"),
            "value": obj.get("value")
        })
        return _obj

Adds a condition on a boolean field.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var metadata_field : ModelField | None

The type of the None singleton.

var model_config

The type of the None singleton.

var value : str | None

The type of the None singleton.

var var_field : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of FindSampleBooleanCondition from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of FindSampleBooleanCondition from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of metadata_field
    if self.metadata_field:
        _dict['metadataField'] = self.metadata_field.to_dict()
    # set to None if metadata_field (nullable) is None
    # and model_fields_set contains the field
    if self.metadata_field is None and "metadata_field" in self.model_fields_set:
        _dict['metadataField'] = None

    # set to None if var_field (nullable) is None
    # and model_fields_set contains the field
    if self.var_field is None and "var_field" in self.model_fields_set:
        _dict['field'] = None

    # set to None if value (nullable) is None
    # and model_fields_set contains the field
    if self.value is None and "value" in self.model_fields_set:
        _dict['value'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class FindSampleCondition (**data: Any)

Expand source code

class FindSampleCondition(BaseModel):
    """
    Adds a condition on a string field.
    """ # noqa: E501
    metadata_field: Optional[FieldId] = Field(default=None, alias="metadataField")
    var_field: Optional[StrictStr] = Field(default=None, alias="field")
    match_mode: Optional[StrictStr] = Field(default=None, description="Defines how the value will be matched.", alias="matchMode")
    values: List[StrictStr]
    __properties: ClassVar[List[str]] = ["metadataField", "field", "matchMode", "values"]

    @field_validator('match_mode')
    def match_mode_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['EXACT', 'EXCLUDE', 'FUZZY']):
            raise ValueError("must be one of enum values ('EXACT', 'EXCLUDE', 'FUZZY')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of FindSampleCondition from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of metadata_field
        if self.metadata_field:
            _dict['metadataField'] = self.metadata_field.to_dict()
        # set to None if metadata_field (nullable) is None
        # and model_fields_set contains the field
        if self.metadata_field is None and "metadata_field" in self.model_fields_set:
            _dict['metadataField'] = None

        # set to None if var_field (nullable) is None
        # and model_fields_set contains the field
        if self.var_field is None and "var_field" in self.model_fields_set:
            _dict['field'] = None

        # set to None if match_mode (nullable) is None
        # and model_fields_set contains the field
        if self.match_mode is None and "match_mode" in self.model_fields_set:
            _dict['matchMode'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of FindSampleCondition from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "metadataField": FieldId.from_dict(obj["metadataField"]) if obj.get("metadataField") is not None else None,
            "field": obj.get("field"),
            "matchMode": obj.get("matchMode"),
            "values": obj.get("values")
        })
        return _obj

Adds a condition on a string field.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var match_mode : str | None

The type of the None singleton.

var metadata_field : FieldId | None

The type of the None singleton.

var model_config

The type of the None singleton.

var values : List[str]

The type of the None singleton.

var var_field : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of FindSampleCondition from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of FindSampleCondition from a JSON string

def match_mode_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of metadata_field
    if self.metadata_field:
        _dict['metadataField'] = self.metadata_field.to_dict()
    # set to None if metadata_field (nullable) is None
    # and model_fields_set contains the field
    if self.metadata_field is None and "metadata_field" in self.model_fields_set:
        _dict['metadataField'] = None

    # set to None if var_field (nullable) is None
    # and model_fields_set contains the field
    if self.var_field is None and "var_field" in self.model_fields_set:
        _dict['field'] = None

    # set to None if match_mode (nullable) is None
    # and model_fields_set contains the field
    if self.match_mode is None and "match_mode" in self.model_fields_set:
        _dict['matchMode'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class FindSampleDateCondition (**data: Any)

Expand source code

class FindSampleDateCondition(BaseModel):
    """
    Adds a condition on a date metadate field. If both the dateBefore and dateAfter parameter are null it will return any sample that has no value for the date field.
    """ # noqa: E501
    metadata_field: Optional[FieldId] = Field(default=None, alias="metadataField")
    var_field: Optional[StrictStr] = Field(default=None, alias="field")
    before_date: Optional[StrictStr] = Field(default=None, description="Before date. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z", alias="beforeDate")
    after_date: Optional[StrictStr] = Field(default=None, description="After date. Format: yyyy-MM-dd'T'HH:mm:ss.SSS'Z' eg: 2017-01-10T10:47:56.039Z", alias="afterDate")
    __properties: ClassVar[List[str]] = ["metadataField", "field", "beforeDate", "afterDate"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of FindSampleDateCondition from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of metadata_field
        if self.metadata_field:
            _dict['metadataField'] = self.metadata_field.to_dict()
        # set to None if metadata_field (nullable) is None
        # and model_fields_set contains the field
        if self.metadata_field is None and "metadata_field" in self.model_fields_set:
            _dict['metadataField'] = None

        # set to None if var_field (nullable) is None
        # and model_fields_set contains the field
        if self.var_field is None and "var_field" in self.model_fields_set:
            _dict['field'] = None

        # set to None if before_date (nullable) is None
        # and model_fields_set contains the field
        if self.before_date is None and "before_date" in self.model_fields_set:
            _dict['beforeDate'] = None

        # set to None if after_date (nullable) is None
        # and model_fields_set contains the field
        if self.after_date is None and "after_date" in self.model_fields_set:
            _dict['afterDate'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of FindSampleDateCondition from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "metadataField": FieldId.from_dict(obj["metadataField"]) if obj.get("metadataField") is not None else None,
            "field": obj.get("field"),
            "beforeDate": obj.get("beforeDate"),
            "afterDate": obj.get("afterDate")
        })
        return _obj

Adds a condition on a date metadate field. If both the dateBefore and dateAfter parameter are null it will return any sample that has no value for the date field.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var after_date : str | None

The type of the None singleton.

var before_date : str | None

The type of the None singleton.

var metadata_field : FieldId | None

The type of the None singleton.

var model_config

The type of the None singleton.

var var_field : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of FindSampleDateCondition from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of FindSampleDateCondition from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of metadata_field
    if self.metadata_field:
        _dict['metadataField'] = self.metadata_field.to_dict()
    # set to None if metadata_field (nullable) is None
    # and model_fields_set contains the field
    if self.metadata_field is None and "metadata_field" in self.model_fields_set:
        _dict['metadataField'] = None

    # set to None if var_field (nullable) is None
    # and model_fields_set contains the field
    if self.var_field is None and "var_field" in self.model_fields_set:
        _dict['field'] = None

    # set to None if before_date (nullable) is None
    # and model_fields_set contains the field
    if self.before_date is None and "before_date" in self.model_fields_set:
        _dict['beforeDate'] = None

    # set to None if after_date (nullable) is None
    # and model_fields_set contains the field
    if self.after_date is None and "after_date" in self.model_fields_set:
        _dict['afterDate'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class FindSampleNumberCondition (**data: Any)

Expand source code

class FindSampleNumberCondition(BaseModel):
    """
    Adds a condition on a number metadata field. If both the lowerBoundary and upperBoundary parameter are null it will return any sample that has no value for the number field.
    """ # noqa: E501
    metadata_field: Optional[FieldId] = Field(default=None, alias="metadataField")
    var_field: Optional[StrictStr] = Field(default=None, alias="field")
    lower_bound: Optional[StrictStr] = Field(default=None, alias="lowerBound")
    upper_bound: Optional[StrictStr] = Field(default=None, alias="upperBound")
    __properties: ClassVar[List[str]] = ["metadataField", "field", "lowerBound", "upperBound"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of FindSampleNumberCondition from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of metadata_field
        if self.metadata_field:
            _dict['metadataField'] = self.metadata_field.to_dict()
        # set to None if metadata_field (nullable) is None
        # and model_fields_set contains the field
        if self.metadata_field is None and "metadata_field" in self.model_fields_set:
            _dict['metadataField'] = None

        # set to None if var_field (nullable) is None
        # and model_fields_set contains the field
        if self.var_field is None and "var_field" in self.model_fields_set:
            _dict['field'] = None

        # set to None if lower_bound (nullable) is None
        # and model_fields_set contains the field
        if self.lower_bound is None and "lower_bound" in self.model_fields_set:
            _dict['lowerBound'] = None

        # set to None if upper_bound (nullable) is None
        # and model_fields_set contains the field
        if self.upper_bound is None and "upper_bound" in self.model_fields_set:
            _dict['upperBound'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of FindSampleNumberCondition from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "metadataField": FieldId.from_dict(obj["metadataField"]) if obj.get("metadataField") is not None else None,
            "field": obj.get("field"),
            "lowerBound": obj.get("lowerBound"),
            "upperBound": obj.get("upperBound")
        })
        return _obj

Adds a condition on a number metadata field. If both the lowerBoundary and upperBoundary parameter are null it will return any sample that has no value for the number field.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var lower_bound : str | None

The type of the None singleton.

var metadata_field : FieldId | None

The type of the None singleton.

var model_config

The type of the None singleton.

var upper_bound : str | None

The type of the None singleton.

var var_field : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of FindSampleNumberCondition from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of FindSampleNumberCondition from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of metadata_field
    if self.metadata_field:
        _dict['metadataField'] = self.metadata_field.to_dict()
    # set to None if metadata_field (nullable) is None
    # and model_fields_set contains the field
    if self.metadata_field is None and "metadata_field" in self.model_fields_set:
        _dict['metadataField'] = None

    # set to None if var_field (nullable) is None
    # and model_fields_set contains the field
    if self.var_field is None and "var_field" in self.model_fields_set:
        _dict['field'] = None

    # set to None if lower_bound (nullable) is None
    # and model_fields_set contains the field
    if self.lower_bound is None and "lower_bound" in self.model_fields_set:
        _dict['lowerBound'] = None

    # set to None if upper_bound (nullable) is None
    # and model_fields_set contains the field
    if self.upper_bound is None and "upper_bound" in self.model_fields_set:
        _dict['upperBound'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class FolderDetails (**data: Any)

Expand source code

class FolderDetails(BaseModel):
    """
    FolderDetails
    """ # noqa: E501
    non_indexed: StrictBool = Field(description="Indicates this is a non-indexed folder", alias="nonIndexed")
    __properties: ClassVar[List[str]] = ["nonIndexed"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of FolderDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of FolderDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "nonIndexed": obj.get("nonIndexed")
        })
        return _obj

FolderDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var non_indexed : bool

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of FolderDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of FolderDetails from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class FolderUploadSession (**data: Any)

Expand source code

class FolderUploadSession(BaseModel):
    """
    FolderUploadSession
    """ # noqa: E501
    id: StrictStr = Field(description="The id of the folder upload session.")
    time_created: datetime = Field(description="The time the folder upload session was created.", alias="timeCreated")
    status: StrictStr = Field(description="The status of the folder upload session.")
    time_session_expires: datetime = Field(description="The time the folder upload session will expire as it is only temporarily valid.", alias="timeSessionExpires")
    time_completed: Optional[datetime] = Field(default=None, description="The time the folder upload session completed.", alias="timeCompleted")
    time_closed: Optional[datetime] = Field(default=None, description="The time the folder upload session was closed.", alias="timeClosed")
    temp_credentials: Optional[TempCredentials] = Field(default=None, alias="tempCredentials")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "status", "timeSessionExpires", "timeCompleted", "timeClosed", "tempCredentials"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['OPEN', 'CLOSED', 'COMPLETED']):
            raise ValueError("must be one of enum values ('OPEN', 'CLOSED', 'COMPLETED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of FolderUploadSession from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of temp_credentials
        if self.temp_credentials:
            _dict['tempCredentials'] = self.temp_credentials.to_dict()
        # set to None if time_completed (nullable) is None
        # and model_fields_set contains the field
        if self.time_completed is None and "time_completed" in self.model_fields_set:
            _dict['timeCompleted'] = None

        # set to None if time_closed (nullable) is None
        # and model_fields_set contains the field
        if self.time_closed is None and "time_closed" in self.model_fields_set:
            _dict['timeClosed'] = None

        # set to None if temp_credentials (nullable) is None
        # and model_fields_set contains the field
        if self.temp_credentials is None and "temp_credentials" in self.model_fields_set:
            _dict['tempCredentials'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of FolderUploadSession from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "status": obj.get("status"),
            "timeSessionExpires": obj.get("timeSessionExpires"),
            "timeCompleted": obj.get("timeCompleted"),
            "timeClosed": obj.get("timeClosed"),
            "tempCredentials": TempCredentials.from_dict(obj["tempCredentials"]) if obj.get("tempCredentials") is not None else None
        })
        return _obj

FolderUploadSession

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

var temp_credentials : TempCredentials | None

The type of the None singleton.

var time_closed : datetime.datetime | None

The type of the None singleton.

var time_completed : datetime.datetime | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_session_expires : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of FolderUploadSession from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of FolderUploadSession from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of temp_credentials
    if self.temp_credentials:
        _dict['tempCredentials'] = self.temp_credentials.to_dict()
    # set to None if time_completed (nullable) is None
    # and model_fields_set contains the field
    if self.time_completed is None and "time_completed" in self.model_fields_set:
        _dict['timeCompleted'] = None

    # set to None if time_closed (nullable) is None
    # and model_fields_set contains the field
    if self.time_closed is None and "time_closed" in self.model_fields_set:
        _dict['timeClosed'] = None

    # set to None if temp_credentials (nullable) is None
    # and model_fields_set contains the field
    if self.temp_credentials is None and "temp_credentials" in self.model_fields_set:
        _dict['tempCredentials'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InlineView (**data: Any)

Expand source code

class InlineView(BaseModel):
    """
    InlineView
    """ # noqa: E501
    url: StrictStr = Field(description="A pre-signed url which is temporarily available for inline viewing the data.")
    __properties: ClassVar[List[str]] = ["url"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InlineView from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InlineView from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "url": obj.get("url")
        })
        return _obj

InlineView

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InlineView from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InlineView from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormBaseSpaceDataDetails (**data: Any)

Expand source code

class InputFormBaseSpaceDataDetails(BaseModel):
    """
    InputFormBaseSpaceDataDetails
    """ # noqa: E501
    workgroup_id: Optional[StrictStr] = Field(default=None, alias="workgroupId")
    extensions: Optional[StrictStr] = None
    path_prefix: Optional[StrictStr] = Field(default=None, alias="pathPrefix")
    __properties: ClassVar[List[str]] = ["workgroupId", "extensions", "pathPrefix"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormBaseSpaceDataDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if workgroup_id (nullable) is None
        # and model_fields_set contains the field
        if self.workgroup_id is None and "workgroup_id" in self.model_fields_set:
            _dict['workgroupId'] = None

        # set to None if extensions (nullable) is None
        # and model_fields_set contains the field
        if self.extensions is None and "extensions" in self.model_fields_set:
            _dict['extensions'] = None

        # set to None if path_prefix (nullable) is None
        # and model_fields_set contains the field
        if self.path_prefix is None and "path_prefix" in self.model_fields_set:
            _dict['pathPrefix'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormBaseSpaceDataDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "workgroupId": obj.get("workgroupId"),
            "extensions": obj.get("extensions"),
            "pathPrefix": obj.get("pathPrefix")
        })
        return _obj

InputFormBaseSpaceDataDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var extensions : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var path_prefix : str | None

The type of the None singleton.

var workgroup_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormBaseSpaceDataDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormBaseSpaceDataDetails from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if workgroup_id (nullable) is None
    # and model_fields_set contains the field
    if self.workgroup_id is None and "workgroup_id" in self.model_fields_set:
        _dict['workgroupId'] = None

    # set to None if extensions (nullable) is None
    # and model_fields_set contains the field
    if self.extensions is None and "extensions" in self.model_fields_set:
        _dict['extensions'] = None

    # set to None if path_prefix (nullable) is None
    # and model_fields_set contains the field
    if self.path_prefix is None and "path_prefix" in self.model_fields_set:
        _dict['pathPrefix'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormData (**data: Any)

Expand source code

class InputFormData(BaseModel):
    """
    Use 'dataValues' for data fields.
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    mount_path: Optional[StrictStr] = Field(default=None, alias="mountPath")
    __properties: ClassVar[List[str]] = ["dataId", "mountPath"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId"),
            "mountPath": obj.get("mountPath")
        })
        return _obj

Use 'dataValues' for data fields.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var mount_path : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormExternalData (**data: Any)

Expand source code

class InputFormExternalData(BaseModel):
    """
    InputFormExternalData
    """ # noqa: E501
    url: StrictStr
    type: Annotated[str, Field(strict=True)]
    s3_details: Optional[InputFormS3DataDetails] = Field(default=None, alias="s3Details")
    basespace_details: Optional[InputFormBaseSpaceDataDetails] = Field(default=None, alias="basespaceDetails")
    __properties: ClassVar[List[str]] = ["url", "type", "s3Details", "basespaceDetails"]

    @field_validator('type')
    def type_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"s3|http|basespace", value):
            raise ValueError(r"must validate the regular expression /s3|http|basespace/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormExternalData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of s3_details
        if self.s3_details:
            _dict['s3Details'] = self.s3_details.to_dict()
        # override the default output from pydantic by calling `to_dict()` of basespace_details
        if self.basespace_details:
            _dict['basespaceDetails'] = self.basespace_details.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormExternalData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "url": obj.get("url"),
            "type": obj.get("type"),
            "s3Details": InputFormS3DataDetails.from_dict(obj["s3Details"]) if obj.get("s3Details") is not None else None,
            "basespaceDetails": InputFormBaseSpaceDataDetails.from_dict(obj["basespaceDetails"]) if obj.get("basespaceDetails") is not None else None
        })
        return _obj

InputFormExternalData

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var basespace_details : InputFormBaseSpaceDataDetails | None

The type of the None singleton.

var model_config

The type of the None singleton.

var s3_details : InputFormS3DataDetails | None

The type of the None singleton.

var type : str

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormExternalData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormExternalData from a JSON string

def type_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of s3_details
    if self.s3_details:
        _dict['s3Details'] = self.s3_details.to_dict()
    # override the default output from pydantic by calling `to_dict()` of basespace_details
    if self.basespace_details:
        _dict['basespaceDetails'] = self.basespace_details.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormField (**data: Any)

Expand source code

class InputFormField(BaseModel):
    """
    InputFormField
    """ # noqa: E501
    id: Optional[StrictStr] = None
    type: Optional[StrictStr] = None
    label: Optional[StrictStr] = None
    min_values: Optional[StrictInt] = Field(default=None, alias="minValues")
    max_values: Optional[StrictInt] = Field(default=None, alias="maxValues")
    min_max_values_message: Optional[StrictStr] = Field(default=None, alias="minMaxValuesMessage")
    help_text: Optional[StrictStr] = Field(default=None, alias="helpText")
    place_holder_text: Optional[StrictStr] = Field(default=None, alias="placeHolderText")
    values: Optional[List[StrictStr]] = None
    data_values: Optional[List[InputFormWithExternalData]] = Field(default=None, alias="dataValues")
    group_values: Optional[List[InputFormGroupFieldValues]] = Field(default=None, alias="groupValues")
    min_length: Optional[StrictInt] = Field(default=None, alias="minLength")
    max_length: Optional[StrictInt] = Field(default=None, alias="maxLength")
    min: Optional[Union[StrictFloat, StrictInt]] = None
    max: Optional[Union[StrictFloat, StrictInt]] = None
    choices: Optional[List[InputFormFieldChoice]] = None
    fields: Optional[List[InputFormGroupField]] = None
    data_filter: Optional[InputFormFieldDataFilter] = Field(default=None, alias="dataFilter")
    regex: Optional[StrictStr] = None
    regex_error_message: Optional[StrictStr] = Field(default=None, alias="regexErrorMessage")
    hidden: Optional[StrictBool] = None
    disabled: Optional[StrictBool] = None
    empty_values_allowed: Optional[StrictBool] = Field(default=None, alias="emptyValuesAllowed")
    update_render_on_change: Optional[StrictBool] = Field(default=None, alias="updateRenderOnChange")
    sensitive: Optional[StrictBool] = None
    __properties: ClassVar[List[str]] = ["id", "type", "label", "minValues", "maxValues", "minMaxValuesMessage", "helpText", "placeHolderText", "values", "dataValues", "groupValues", "minLength", "maxLength", "min", "max", "choices", "fields", "dataFilter", "regex", "regexErrorMessage", "hidden", "disabled", "emptyValuesAllowed", "updateRenderOnChange", "sensitive"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormField from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in data_values (list)
        _items = []
        if self.data_values:
            for _item_data_values in self.data_values:
                if _item_data_values:
                    _items.append(_item_data_values.to_dict())
            _dict['dataValues'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in group_values (list)
        _items = []
        if self.group_values:
            for _item_group_values in self.group_values:
                if _item_group_values:
                    _items.append(_item_group_values.to_dict())
            _dict['groupValues'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in choices (list)
        _items = []
        if self.choices:
            for _item_choices in self.choices:
                if _item_choices:
                    _items.append(_item_choices.to_dict())
            _dict['choices'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
        _items = []
        if self.fields:
            for _item_fields in self.fields:
                if _item_fields:
                    _items.append(_item_fields.to_dict())
            _dict['fields'] = _items
        # override the default output from pydantic by calling `to_dict()` of data_filter
        if self.data_filter:
            _dict['dataFilter'] = self.data_filter.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormField from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "type": obj.get("type"),
            "label": obj.get("label"),
            "minValues": obj.get("minValues"),
            "maxValues": obj.get("maxValues"),
            "minMaxValuesMessage": obj.get("minMaxValuesMessage"),
            "helpText": obj.get("helpText"),
            "placeHolderText": obj.get("placeHolderText"),
            "values": obj.get("values"),
            "dataValues": [InputFormWithExternalData.from_dict(_item) for _item in obj["dataValues"]] if obj.get("dataValues") is not None else None,
            "groupValues": [InputFormGroupFieldValues.from_dict(_item) for _item in obj["groupValues"]] if obj.get("groupValues") is not None else None,
            "minLength": obj.get("minLength"),
            "maxLength": obj.get("maxLength"),
            "min": obj.get("min"),
            "max": obj.get("max"),
            "choices": [InputFormFieldChoice.from_dict(_item) for _item in obj["choices"]] if obj.get("choices") is not None else None,
            "fields": [InputFormGroupField.from_dict(_item) for _item in obj["fields"]] if obj.get("fields") is not None else None,
            "dataFilter": InputFormFieldDataFilter.from_dict(obj["dataFilter"]) if obj.get("dataFilter") is not None else None,
            "regex": obj.get("regex"),
            "regexErrorMessage": obj.get("regexErrorMessage"),
            "hidden": obj.get("hidden"),
            "disabled": obj.get("disabled"),
            "emptyValuesAllowed": obj.get("emptyValuesAllowed"),
            "updateRenderOnChange": obj.get("updateRenderOnChange"),
            "sensitive": obj.get("sensitive")
        })
        return _obj

InputFormField

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var choices : List[InputFormFieldChoice] | None

The type of the None singleton.

var data_filter : InputFormFieldDataFilter | None

The type of the None singleton.

var data_values : List[InputFormWithExternalData] | None

The type of the None singleton.

var disabled : bool | None

The type of the None singleton.

var empty_values_allowed : bool | None

The type of the None singleton.

var fields : List[InputFormGroupField] | None

The type of the None singleton.

var group_values : List[InputFormGroupFieldValues] | None

The type of the None singleton.

var help_text : str | None

The type of the None singleton.

var hidden : bool | None

The type of the None singleton.

var id : str | None

The type of the None singleton.

var label : str | None

The type of the None singleton.

var max : float | int | None

The type of the None singleton.

var max_length : int | None

The type of the None singleton.

var max_values : int | None

The type of the None singleton.

var min : float | int | None

The type of the None singleton.

var min_length : int | None

The type of the None singleton.

var min_max_values_message : str | None

The type of the None singleton.

var min_values : int | None

The type of the None singleton.

var model_config

The type of the None singleton.

var place_holder_text : str | None

The type of the None singleton.

var regex : str | None

The type of the None singleton.

var regex_error_message : str | None

The type of the None singleton.

var sensitive : bool | None

The type of the None singleton.

var type : str | None

The type of the None singleton.

var update_render_on_change : bool | None

The type of the None singleton.

var values : List[str] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormField from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormField from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in data_values (list)
    _items = []
    if self.data_values:
        for _item_data_values in self.data_values:
            if _item_data_values:
                _items.append(_item_data_values.to_dict())
        _dict['dataValues'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in group_values (list)
    _items = []
    if self.group_values:
        for _item_group_values in self.group_values:
            if _item_group_values:
                _items.append(_item_group_values.to_dict())
        _dict['groupValues'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in choices (list)
    _items = []
    if self.choices:
        for _item_choices in self.choices:
            if _item_choices:
                _items.append(_item_choices.to_dict())
        _dict['choices'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
    _items = []
    if self.fields:
        for _item_fields in self.fields:
            if _item_fields:
                _items.append(_item_fields.to_dict())
        _dict['fields'] = _items
    # override the default output from pydantic by calling `to_dict()` of data_filter
    if self.data_filter:
        _dict['dataFilter'] = self.data_filter.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormFieldChoice (**data: Any)

Expand source code

class InputFormFieldChoice(BaseModel):
    """
    InputFormFieldChoice
    """ # noqa: E501
    value: Optional[StrictStr] = None
    text: Optional[StrictStr] = None
    selected: Optional[StrictBool] = None
    disabled: Optional[StrictBool] = None
    __properties: ClassVar[List[str]] = ["value", "text", "selected", "disabled"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormFieldChoice from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormFieldChoice from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "value": obj.get("value"),
            "text": obj.get("text"),
            "selected": obj.get("selected"),
            "disabled": obj.get("disabled")
        })
        return _obj

InputFormFieldChoice

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var disabled : bool | None

The type of the None singleton.

var model_config

The type of the None singleton.

var selected : bool | None

The type of the None singleton.

var text : str | None

The type of the None singleton.

var value : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormFieldChoice from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormFieldChoice from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormFieldDataFilter (**data: Any)

Expand source code

class InputFormFieldDataFilter(BaseModel):
    """
    InputFormFieldDataFilter
    """ # noqa: E501
    name_filter: Optional[StrictStr] = Field(default=None, alias="nameFilter")
    data_format: Optional[List[StrictStr]] = Field(default=None, alias="dataFormat")
    data_type: Optional[StrictStr] = Field(default=None, alias="dataType")
    __properties: ClassVar[List[str]] = ["nameFilter", "dataFormat", "dataType"]

    @field_validator('data_type')
    def data_type_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['FILE', 'DIRECTORY']):
            raise ValueError("must be one of enum values ('FILE', 'DIRECTORY')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormFieldDataFilter from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormFieldDataFilter from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "nameFilter": obj.get("nameFilter"),
            "dataFormat": obj.get("dataFormat"),
            "dataType": obj.get("dataType")
        })
        return _obj

InputFormFieldDataFilter

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_format : List[str] | None

The type of the None singleton.

var data_type : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name_filter : str | None

The type of the None singleton.

Static methods

def data_type_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormFieldDataFilter from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormFieldDataFilter from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormFieldList (**data: Any)

Expand source code

class InputFormFieldList(BaseModel):
    """
    InputFormFieldList
    """ # noqa: E501
    items: List[InputFormField]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormFieldList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormFieldList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [InputFormField.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

InputFormFieldList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[InputFormField]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormFieldList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormFieldList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormFieldValues (**data: Any)

Expand source code

class InputFormFieldValues(BaseModel):
    """
    InputFormFieldValues
    """ # noqa: E501
    id: StrictStr
    values: Optional[List[Optional[StrictStr]]] = Field(default=None, description="Use 'values' for all fields except data fields. Use string values to avoid rounding of numbers with a high precision. '' values for textbox type fields will be treated as null.")
    data_values: Optional[List[Optional[InputFormData]]] = Field(default=None, description="Use 'dataValues' for data fields.", alias="dataValues")
    external_data_values: Optional[List[Optional[AnalysisInputExternalData]]] = Field(default=None, description="Use 'externalDataValues' for external data", alias="externalDataValues")
    __properties: ClassVar[List[str]] = ["id", "values", "dataValues", "externalDataValues"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormFieldValues from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in data_values (list)
        _items = []
        if self.data_values:
            for _item_data_values in self.data_values:
                if _item_data_values:
                    _items.append(_item_data_values.to_dict())
            _dict['dataValues'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in external_data_values (list)
        _items = []
        if self.external_data_values:
            for _item_external_data_values in self.external_data_values:
                if _item_external_data_values:
                    _items.append(_item_external_data_values.to_dict())
            _dict['externalDataValues'] = _items
        # set to None if values (nullable) is None
        # and model_fields_set contains the field
        if self.values is None and "values" in self.model_fields_set:
            _dict['values'] = None

        # set to None if data_values (nullable) is None
        # and model_fields_set contains the field
        if self.data_values is None and "data_values" in self.model_fields_set:
            _dict['dataValues'] = None

        # set to None if external_data_values (nullable) is None
        # and model_fields_set contains the field
        if self.external_data_values is None and "external_data_values" in self.model_fields_set:
            _dict['externalDataValues'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormFieldValues from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "values": obj.get("values"),
            "dataValues": [InputFormData.from_dict(_item) for _item in obj["dataValues"]] if obj.get("dataValues") is not None else None,
            "externalDataValues": [AnalysisInputExternalData.from_dict(_item) for _item in obj["externalDataValues"]] if obj.get("externalDataValues") is not None else None
        })
        return _obj

InputFormFieldValues

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_values : List[InputFormData | None] | None

The type of the None singleton.

var external_data_values : List[AnalysisInputExternalData | None] | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var values : List[str | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormFieldValues from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormFieldValues from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in data_values (list)
    _items = []
    if self.data_values:
        for _item_data_values in self.data_values:
            if _item_data_values:
                _items.append(_item_data_values.to_dict())
        _dict['dataValues'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in external_data_values (list)
    _items = []
    if self.external_data_values:
        for _item_external_data_values in self.external_data_values:
            if _item_external_data_values:
                _items.append(_item_external_data_values.to_dict())
        _dict['externalDataValues'] = _items
    # set to None if values (nullable) is None
    # and model_fields_set contains the field
    if self.values is None and "values" in self.model_fields_set:
        _dict['values'] = None

    # set to None if data_values (nullable) is None
    # and model_fields_set contains the field
    if self.data_values is None and "data_values" in self.model_fields_set:
        _dict['dataValues'] = None

    # set to None if external_data_values (nullable) is None
    # and model_fields_set contains the field
    if self.external_data_values is None and "external_data_values" in self.model_fields_set:
        _dict['externalDataValues'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormGroup (**data: Any)

Expand source code

class InputFormGroup(BaseModel):
    """
    InputFormGroup
    """ # noqa: E501
    id: StrictStr
    values: Optional[List[InputFormGroupFieldValues]] = None
    __properties: ClassVar[List[str]] = ["id", "values"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormGroup from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in values (list)
        _items = []
        if self.values:
            for _item_values in self.values:
                if _item_values:
                    _items.append(_item_values.to_dict())
            _dict['values'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormGroup from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "values": [InputFormGroupFieldValues.from_dict(_item) for _item in obj["values"]] if obj.get("values") is not None else None
        })
        return _obj

InputFormGroup

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var values : List[InputFormGroupFieldValues] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormGroup from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormGroup from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in values (list)
    _items = []
    if self.values:
        for _item_values in self.values:
            if _item_values:
                _items.append(_item_values.to_dict())
        _dict['values'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormGroupField (**data: Any)

Expand source code

class InputFormGroupField(BaseModel):
    """
    InputFormGroupField
    """ # noqa: E501
    id: Optional[StrictStr] = None
    type: Optional[StrictStr] = None
    label: Optional[StrictStr] = None
    min_values: Optional[StrictInt] = Field(default=None, alias="minValues")
    max_values: Optional[StrictInt] = Field(default=None, alias="maxValues")
    min_max_values_message: Optional[StrictStr] = Field(default=None, alias="minMaxValuesMessage")
    help_text: Optional[StrictStr] = Field(default=None, alias="helpText")
    place_holder_text: Optional[StrictStr] = Field(default=None, alias="placeHolderText")
    values: Optional[List[StrictStr]] = None
    data_values: Optional[List[InputFormWithExternalData]] = Field(default=None, alias="dataValues")
    min_length: Optional[StrictInt] = Field(default=None, alias="minLength")
    max_length: Optional[StrictInt] = Field(default=None, alias="maxLength")
    min: Optional[Union[StrictFloat, StrictInt]] = None
    max: Optional[Union[StrictFloat, StrictInt]] = None
    choices: Optional[List[InputFormFieldChoice]] = None
    data_filter: Optional[InputFormFieldDataFilter] = Field(default=None, alias="dataFilter")
    regex: Optional[StrictStr] = None
    regex_error_message: Optional[StrictStr] = Field(default=None, alias="regexErrorMessage")
    hidden: Optional[StrictBool] = None
    disabled: Optional[StrictBool] = None
    empty_values_allowed: Optional[StrictBool] = Field(default=None, alias="emptyValuesAllowed")
    update_render_on_change: Optional[StrictBool] = Field(default=None, alias="updateRenderOnChange")
    __properties: ClassVar[List[str]] = ["id", "type", "label", "minValues", "maxValues", "minMaxValuesMessage", "helpText", "placeHolderText", "values", "dataValues", "minLength", "maxLength", "min", "max", "choices", "dataFilter", "regex", "regexErrorMessage", "hidden", "disabled", "emptyValuesAllowed", "updateRenderOnChange"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormGroupField from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in data_values (list)
        _items = []
        if self.data_values:
            for _item_data_values in self.data_values:
                if _item_data_values:
                    _items.append(_item_data_values.to_dict())
            _dict['dataValues'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in choices (list)
        _items = []
        if self.choices:
            for _item_choices in self.choices:
                if _item_choices:
                    _items.append(_item_choices.to_dict())
            _dict['choices'] = _items
        # override the default output from pydantic by calling `to_dict()` of data_filter
        if self.data_filter:
            _dict['dataFilter'] = self.data_filter.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormGroupField from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "type": obj.get("type"),
            "label": obj.get("label"),
            "minValues": obj.get("minValues"),
            "maxValues": obj.get("maxValues"),
            "minMaxValuesMessage": obj.get("minMaxValuesMessage"),
            "helpText": obj.get("helpText"),
            "placeHolderText": obj.get("placeHolderText"),
            "values": obj.get("values"),
            "dataValues": [InputFormWithExternalData.from_dict(_item) for _item in obj["dataValues"]] if obj.get("dataValues") is not None else None,
            "minLength": obj.get("minLength"),
            "maxLength": obj.get("maxLength"),
            "min": obj.get("min"),
            "max": obj.get("max"),
            "choices": [InputFormFieldChoice.from_dict(_item) for _item in obj["choices"]] if obj.get("choices") is not None else None,
            "dataFilter": InputFormFieldDataFilter.from_dict(obj["dataFilter"]) if obj.get("dataFilter") is not None else None,
            "regex": obj.get("regex"),
            "regexErrorMessage": obj.get("regexErrorMessage"),
            "hidden": obj.get("hidden"),
            "disabled": obj.get("disabled"),
            "emptyValuesAllowed": obj.get("emptyValuesAllowed"),
            "updateRenderOnChange": obj.get("updateRenderOnChange")
        })
        return _obj

InputFormGroupField

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var choices : List[InputFormFieldChoice] | None

The type of the None singleton.

var data_filter : InputFormFieldDataFilter | None

The type of the None singleton.

var data_values : List[InputFormWithExternalData] | None

The type of the None singleton.

var disabled : bool | None

The type of the None singleton.

var empty_values_allowed : bool | None

The type of the None singleton.

var help_text : str | None

The type of the None singleton.

var hidden : bool | None

The type of the None singleton.

var id : str | None

The type of the None singleton.

var label : str | None

The type of the None singleton.

var max : float | int | None

The type of the None singleton.

var max_length : int | None

The type of the None singleton.

var max_values : int | None

The type of the None singleton.

var min : float | int | None

The type of the None singleton.

var min_length : int | None

The type of the None singleton.

var min_max_values_message : str | None

The type of the None singleton.

var min_values : int | None

The type of the None singleton.

var model_config

The type of the None singleton.

var place_holder_text : str | None

The type of the None singleton.

var regex : str | None

The type of the None singleton.

var regex_error_message : str | None

The type of the None singleton.

var type : str | None

The type of the None singleton.

var update_render_on_change : bool | None

The type of the None singleton.

var values : List[str] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormGroupField from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormGroupField from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in data_values (list)
    _items = []
    if self.data_values:
        for _item_data_values in self.data_values:
            if _item_data_values:
                _items.append(_item_data_values.to_dict())
        _dict['dataValues'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in choices (list)
    _items = []
    if self.choices:
        for _item_choices in self.choices:
            if _item_choices:
                _items.append(_item_choices.to_dict())
        _dict['choices'] = _items
    # override the default output from pydantic by calling `to_dict()` of data_filter
    if self.data_filter:
        _dict['dataFilter'] = self.data_filter.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormGroupFieldValues (**data: Any)

Expand source code

class InputFormGroupFieldValues(BaseModel):
    """
    InputFormGroupFieldValues
    """ # noqa: E501
    values: Optional[List[InputFormFieldValues]] = None
    __properties: ClassVar[List[str]] = ["values"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormGroupFieldValues from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in values (list)
        _items = []
        if self.values:
            for _item_values in self.values:
                if _item_values:
                    _items.append(_item_values.to_dict())
            _dict['values'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormGroupFieldValues from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "values": [InputFormFieldValues.from_dict(_item) for _item in obj["values"]] if obj.get("values") is not None else None
        })
        return _obj

InputFormGroupFieldValues

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var values : List[InputFormFieldValues] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormGroupFieldValues from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormGroupFieldValues from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in values (list)
    _items = []
    if self.values:
        for _item_values in self.values:
            if _item_values:
                _items.append(_item_values.to_dict())
        _dict['values'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormS3DataDetails (**data: Any)

Expand source code

class InputFormS3DataDetails(BaseModel):
    """
    InputFormS3DataDetails
    """ # noqa: E501
    storage_credentials_id: Optional[StrictStr] = Field(default=None, description="The storage credentials with the S3 access key.", alias="storageCredentialsId")
    __properties: ClassVar[List[str]] = ["storageCredentialsId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormS3DataDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if storage_credentials_id (nullable) is None
        # and model_fields_set contains the field
        if self.storage_credentials_id is None and "storage_credentials_id" in self.model_fields_set:
            _dict['storageCredentialsId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormS3DataDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "storageCredentialsId": obj.get("storageCredentialsId")
        })
        return _obj

InputFormS3DataDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var storage_credentials_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormS3DataDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormS3DataDetails from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if storage_credentials_id (nullable) is None
    # and model_fields_set contains the field
    if self.storage_credentials_id is None and "storage_credentials_id" in self.model_fields_set:
        _dict['storageCredentialsId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputFormWithExternalData (**data: Any)

Expand source code

class InputFormWithExternalData(BaseModel):
    """
    InputFormWithExternalData
    """ # noqa: E501
    data_id: Optional[StrictStr] = Field(default=None, alias="dataId")
    external_data: Optional[InputFormExternalData] = Field(default=None, alias="externalData")
    mount_path: Optional[StrictStr] = Field(default=None, alias="mountPath")
    __properties: ClassVar[List[str]] = ["dataId", "externalData", "mountPath"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputFormWithExternalData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of external_data
        if self.external_data:
            _dict['externalData'] = self.external_data.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputFormWithExternalData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId"),
            "externalData": InputFormExternalData.from_dict(obj["externalData"]) if obj.get("externalData") is not None else None,
            "mountPath": obj.get("mountPath")
        })
        return _obj

InputFormWithExternalData

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str | None

The type of the None singleton.

var external_data : InputFormExternalData | None

The type of the None singleton.

var model_config

The type of the None singleton.

var mount_path : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputFormWithExternalData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputFormWithExternalData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of external_data
    if self.external_data:
        _dict['externalData'] = self.external_data.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputParameter (**data: Any)

Expand source code

class InputParameter(BaseModel):
    """
    InputParameter
    """ # noqa: E501
    id: StrictStr = Field(description="The ID of the parameter")
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The code of the parameter")
    required: StrictBool = Field(description="Indicates whether this parameter is required")
    multi_value: StrictBool = Field(description="Indicates whether multiple values are allowed for this parameter", alias="multiValue")
    __properties: ClassVar[List[str]] = ["id", "code", "required", "multiValue"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputParameter from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputParameter from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "code": obj.get("code"),
            "required": obj.get("required"),
            "multiValue": obj.get("multiValue")
        })
        return _obj

InputParameter

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var multi_value : bool

The type of the None singleton.

var required : bool

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputParameter from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputParameter from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputParameterList (**data: Any)

Expand source code

class InputParameterList(BaseModel):
    """
    InputParameterList
    """ # noqa: E501
    items: List[InputParameter]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputParameterList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputParameterList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [InputParameter.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

InputParameterList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[InputParameter]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputParameterList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputParameterList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputPart (**data: Any)

Expand source code

class InputPart(BaseModel):
    """
    InputPart
    """ # noqa: E501
    body_as_string: Optional[StrictStr] = Field(default=None, alias="bodyAsString")
    content_type_from_message: Optional[StrictBool] = Field(default=None, alias="contentTypeFromMessage")
    media_type: Optional[InputPartMediaType] = Field(default=None, alias="mediaType")
    headers: Optional[Dict[str, List[StrictStr]]] = None
    __properties: ClassVar[List[str]] = ["bodyAsString", "contentTypeFromMessage", "mediaType", "headers"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputPart from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of media_type
        if self.media_type:
            _dict['mediaType'] = self.media_type.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputPart from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "bodyAsString": obj.get("bodyAsString"),
            "contentTypeFromMessage": obj.get("contentTypeFromMessage"),
            "mediaType": InputPartMediaType.from_dict(obj["mediaType"]) if obj.get("mediaType") is not None else None,
            "headers": obj.get("headers")
        })
        return _obj

InputPart

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var body_as_string : str | None

The type of the None singleton.

var content_type_from_message : bool | None

The type of the None singleton.

var headers : Dict[str, List[str]] | None

The type of the None singleton.

var media_type : InputPartMediaType | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputPart from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputPart from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of media_type
    if self.media_type:
        _dict['mediaType'] = self.media_type.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InputPartMediaType (**data: Any)

Expand source code

class InputPartMediaType(BaseModel):
    """
    InputPartMediaType
    """ # noqa: E501
    type: Optional[StrictStr] = None
    subtype: Optional[StrictStr] = None
    parameters: Optional[Dict[str, StrictStr]] = None
    wildcard_subtype: Optional[StrictBool] = Field(default=None, alias="wildcardSubtype")
    wildcard_type: Optional[StrictBool] = Field(default=None, alias="wildcardType")
    __properties: ClassVar[List[str]] = ["type", "subtype", "parameters", "wildcardSubtype", "wildcardType"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InputPartMediaType from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InputPartMediaType from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "type": obj.get("type"),
            "subtype": obj.get("subtype"),
            "parameters": obj.get("parameters"),
            "wildcardSubtype": obj.get("wildcardSubtype"),
            "wildcardType": obj.get("wildcardType")
        })
        return _obj

InputPartMediaType

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var parameters : Dict[str, str] | None

The type of the None singleton.

var subtype : str | None

The type of the None singleton.

var type : str | None

The type of the None singleton.

var wildcard_subtype : bool | None

The type of the None singleton.

var wildcard_type : bool | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InputPartMediaType from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InputPartMediaType from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class IntegerSettings (**data: Any)

Expand source code

class IntegerSettings(BaseModel):
    """
    IntegerSettings
    """ # noqa: E501
    default_values: Optional[List[StrictInt]] = Field(default=None, alias="defaultValues")
    __properties: ClassVar[List[str]] = ["defaultValues"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of IntegerSettings from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of IntegerSettings from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "defaultValues": obj.get("defaultValues")
        })
        return _obj

IntegerSettings

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var default_values : List[int] | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of IntegerSettings from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of IntegerSettings from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class InternalDockerImageSettings (**data: Any)

Expand source code

class InternalDockerImageSettings(BaseModel):
    """
    InternalDockerImageSettings
    """ # noqa: E501
    regions: Optional[List[Optional[DockerImageRegion]]] = None
    __properties: ClassVar[List[str]] = ["regions"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of InternalDockerImageSettings from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in regions (list)
        _items = []
        if self.regions:
            for _item_regions in self.regions:
                if _item_regions:
                    _items.append(_item_regions.to_dict())
            _dict['regions'] = _items
        # set to None if regions (nullable) is None
        # and model_fields_set contains the field
        if self.regions is None and "regions" in self.model_fields_set:
            _dict['regions'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of InternalDockerImageSettings from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "regions": [DockerImageRegion.from_dict(_item) for _item in obj["regions"]] if obj.get("regions") is not None else None
        })
        return _obj

InternalDockerImageSettings

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var regions : List[DockerImageRegion | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of InternalDockerImageSettings from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of InternalDockerImageSettings from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in regions (list)
    _items = []
    if self.regions:
        for _item_regions in self.regions:
            if _item_regions:
                _items.append(_item_regions.to_dict())
        _dict['regions'] = _items
    # set to None if regions (nullable) is None
    # and model_fields_set contains the field
    if self.regions is None and "regions" in self.model_fields_set:
        _dict['regions'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Job (**data: Any)

Expand source code

class Job(BaseModel):
    """
    Job
    """ # noqa: E501
    id: StrictStr
    status: StrictStr
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this job.", alias="additionalStatusInformation")
    subject_type: StrictStr = Field(description="The type of the subject for which this job provides execution.", alias="subjectType")
    subject_id: StrictStr = Field(description="The id of the subject for which this job provides execution.", alias="subjectId")
    time_created: datetime = Field(alias="timeCreated")
    time_started: Optional[datetime] = Field(default=None, alias="timeStarted")
    time_finished: Optional[datetime] = Field(default=None, alias="timeFinished")
    owner: User
    project: Optional[Project] = None
    bundle: Optional[Bundle] = None
    __properties: ClassVar[List[str]] = ["id", "status", "additionalStatusInformation", "subjectType", "subjectId", "timeCreated", "timeStarted", "timeFinished", "owner", "project", "bundle"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['INITIALIZED', 'WAITING_FOR_RESOURCES', 'RUNNING', 'STOPPED', 'SUCCEEDED', 'PARTIALLY_SUCCEEDED', 'FAILED']):
            raise ValueError("must be one of enum values ('INITIALIZED', 'WAITING_FOR_RESOURCES', 'RUNNING', 'STOPPED', 'SUCCEEDED', 'PARTIALLY_SUCCEEDED', 'FAILED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Job from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of owner
        if self.owner:
            _dict['owner'] = self.owner.to_dict()
        # override the default output from pydantic by calling `to_dict()` of project
        if self.project:
            _dict['project'] = self.project.to_dict()
        # override the default output from pydantic by calling `to_dict()` of bundle
        if self.bundle:
            _dict['bundle'] = self.bundle.to_dict()
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        # set to None if time_started (nullable) is None
        # and model_fields_set contains the field
        if self.time_started is None and "time_started" in self.model_fields_set:
            _dict['timeStarted'] = None

        # set to None if time_finished (nullable) is None
        # and model_fields_set contains the field
        if self.time_finished is None and "time_finished" in self.model_fields_set:
            _dict['timeFinished'] = None

        # set to None if bundle (nullable) is None
        # and model_fields_set contains the field
        if self.bundle is None and "bundle" in self.model_fields_set:
            _dict['bundle'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Job from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation"),
            "subjectType": obj.get("subjectType"),
            "subjectId": obj.get("subjectId"),
            "timeCreated": obj.get("timeCreated"),
            "timeStarted": obj.get("timeStarted"),
            "timeFinished": obj.get("timeFinished"),
            "owner": User.from_dict(obj["owner"]) if obj.get("owner") is not None else None,
            "project": Project.from_dict(obj["project"]) if obj.get("project") is not None else None,
            "bundle": Bundle.from_dict(obj["bundle"]) if obj.get("bundle") is not None else None
        })
        return _obj

Job

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var bundle : Bundle | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner : User

The type of the None singleton.

var project : Project | None

The type of the None singleton.

var status : str

The type of the None singleton.

var subject_id : str

The type of the None singleton.

var subject_type : str

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_finished : datetime.datetime | None

The type of the None singleton.

var time_started : datetime.datetime | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Job from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Job from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of owner
    if self.owner:
        _dict['owner'] = self.owner.to_dict()
    # override the default output from pydantic by calling `to_dict()` of project
    if self.project:
        _dict['project'] = self.project.to_dict()
    # override the default output from pydantic by calling `to_dict()` of bundle
    if self.bundle:
        _dict['bundle'] = self.bundle.to_dict()
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    # set to None if time_started (nullable) is None
    # and model_fields_set contains the field
    if self.time_started is None and "time_started" in self.model_fields_set:
        _dict['timeStarted'] = None

    # set to None if time_finished (nullable) is None
    # and model_fields_set contains the field
    if self.time_finished is None and "time_finished" in self.model_fields_set:
        _dict['timeFinished'] = None

    # set to None if bundle (nullable) is None
    # and model_fields_set contains the field
    if self.bundle is None and "bundle" in self.model_fields_set:
        _dict['bundle'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class JobApi (api_client=None)

Expand source code

class JobApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_job(
        self,
        job_id: Annotated[StrictStr, Field(description="The ID of the job.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Job:
        """Retrieve a job.


        :param job_id: The ID of the job. (required)
        :type job_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_job_serialize(
            job_id=job_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Job",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_job_with_http_info(
        self,
        job_id: Annotated[StrictStr, Field(description="The ID of the job.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Job]:
        """Retrieve a job.


        :param job_id: The ID of the job. (required)
        :type job_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_job_serialize(
            job_id=job_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Job",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_job_without_preload_content(
        self,
        job_id: Annotated[StrictStr, Field(description="The ID of the job.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a job.


        :param job_id: The ID of the job. (required)
        :type job_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_job_serialize(
            job_id=job_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Job",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_job_serialize(
        self,
        job_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if job_id is not None:
            _path_params['jobId'] = job_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/jobs/{jobId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_jobs(
        self,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> JobPagedList:
        """Retrieve a list of jobs.


        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_jobs_serialize(
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "JobPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_jobs_with_http_info(
        self,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[JobPagedList]:
        """Retrieve a list of jobs.


        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_jobs_serialize(
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "JobPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_jobs_without_preload_content(
        self,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of jobs.


        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_jobs_serialize(
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "JobPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_jobs_serialize(
        self,
        status,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/jobs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_job(self,
job_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the job.')]) ‑> Job

Expand source code

@validate_call
def get_job(
    self,
    job_id: Annotated[StrictStr, Field(description="The ID of the job.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Job:
    """Retrieve a job.


    :param job_id: The ID of the job. (required)
    :type job_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_job_serialize(
        job_id=job_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Job",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a job.

:param job_id: The ID of the job. (required) :type job_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_job_with_http_info(self,
job_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the job.')]) ‑> ApiResponse[Job]

Expand source code

@validate_call
def get_job_with_http_info(
    self,
    job_id: Annotated[StrictStr, Field(description="The ID of the job.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Job]:
    """Retrieve a job.


    :param job_id: The ID of the job. (required)
    :type job_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_job_serialize(
        job_id=job_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Job",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a job.

:param job_id: The ID of the job. (required) :type job_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_job_without_preload_content(self,
job_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the job.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_job_without_preload_content(
    self,
    job_id: Annotated[StrictStr, Field(description="The ID of the job.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a job.


    :param job_id: The ID of the job. (required)
    :type job_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_job_serialize(
        job_id=job_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Job",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a job.

:param job_id: The ID of the job. (required) :type job_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_jobs(self,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished')] = None) ‑> JobPagedList

Expand source code

@validate_call
def get_jobs(
    self,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> JobPagedList:
    """Retrieve a list of jobs.


    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_jobs_serialize(
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "JobPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of jobs.

:param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_jobs_with_http_info(self,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished')] = None) ‑> ApiResponse[JobPagedList]

Expand source code

@validate_call
def get_jobs_with_http_info(
    self,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[JobPagedList]:
    """Retrieve a list of jobs.


    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_jobs_serialize(
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "JobPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of jobs.

:param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_jobs_without_preload_content(self,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_jobs_without_preload_content(
    self,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of jobs.


    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_jobs_serialize(
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "JobPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of jobs.

:param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeStarted - timeFinished :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class JobPagedList (**data: Any)

Expand source code

class JobPagedList(BaseModel):
    """
    JobPagedList
    """ # noqa: E501
    items: List[Optional[Job]]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of JobPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of JobPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Job.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

JobPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Job | None]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of JobPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of JobPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Link (**data: Any)

Expand source code

class Link(BaseModel):
    """
    Link
    """ # noqa: E501
    name: Annotated[str, Field(min_length=1, strict=True, max_length=100)] = Field(description="The name of the link")
    url: Annotated[str, Field(min_length=1, strict=True, max_length=2048)] = Field(description="The url of the link")
    __properties: ClassVar[List[str]] = ["name", "url"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Link from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Link from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "url": obj.get("url")
        })
        return _obj

Link

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Link from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Link from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Links (**data: Any)

Expand source code

class Links(BaseModel):
    """
    Links
    """ # noqa: E501
    links: Optional[List[Link]] = None
    licenses: Optional[List[Link]] = None
    homepages: Optional[List[Link]] = None
    publications: Optional[List[Link]] = None
    __properties: ClassVar[List[str]] = ["links", "licenses", "homepages", "publications"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Links from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in links (list)
        _items = []
        if self.links:
            for _item_links in self.links:
                if _item_links:
                    _items.append(_item_links.to_dict())
            _dict['links'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in licenses (list)
        _items = []
        if self.licenses:
            for _item_licenses in self.licenses:
                if _item_licenses:
                    _items.append(_item_licenses.to_dict())
            _dict['licenses'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in homepages (list)
        _items = []
        if self.homepages:
            for _item_homepages in self.homepages:
                if _item_homepages:
                    _items.append(_item_homepages.to_dict())
            _dict['homepages'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in publications (list)
        _items = []
        if self.publications:
            for _item_publications in self.publications:
                if _item_publications:
                    _items.append(_item_publications.to_dict())
            _dict['publications'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Links from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "links": [Link.from_dict(_item) for _item in obj["links"]] if obj.get("links") is not None else None,
            "licenses": [Link.from_dict(_item) for _item in obj["licenses"]] if obj.get("licenses") is not None else None,
            "homepages": [Link.from_dict(_item) for _item in obj["homepages"]] if obj.get("homepages") is not None else None,
            "publications": [Link.from_dict(_item) for _item in obj["publications"]] if obj.get("publications") is not None else None
        })
        return _obj

Links

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var homepages : List[Link] | None

The type of the None singleton.

var licenses : List[Link] | None

The type of the None singleton.

var links : List[Link] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var publications : List[Link] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Links from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Links from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in links (list)
    _items = []
    if self.links:
        for _item_links in self.links:
            if _item_links:
                _items.append(_item_links.to_dict())
        _dict['links'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in licenses (list)
    _items = []
    if self.licenses:
        for _item_licenses in self.licenses:
            if _item_licenses:
                _items.append(_item_licenses.to_dict())
        _dict['licenses'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in homepages (list)
    _items = []
    if self.homepages:
        for _item_homepages in self.homepages:
            if _item_homepages:
                _items.append(_item_homepages.to_dict())
        _dict['homepages'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in publications (list)
    _items = []
    if self.publications:
        for _item_publications in self.publications:
            if _item_publications:
                _items.append(_item_publications.to_dict())
        _dict['publications'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class LoadDataInBaseRequest (**data: Any)

Expand source code

class LoadDataInBaseRequest(BaseModel):
    """
    LoadDataInBaseRequest
    """ # noqa: E501
    allow_quoted_newlines: Optional[StrictBool] = Field(default=False, description="Enable to include newlines contained in quoted data sections in the cell's value. When disabled, newlines will signal a new row", alias="allowQuotedNewlines")
    data_id: StrictStr = Field(description="ID of the data to load into the table", alias="dataId")
    delimiter: Optional[StrictStr] = Field(default=',', description="field delimiter")
    encoding: Optional[StrictStr] = Field(default='UTF8', description="Encoding")
    force_load: Optional[StrictBool] = Field(default=False, description="When false (default): the data will not be loaded if it was already previously loaded to table ; when true, the data will be loaded even if already loaded in the past", alias="forceLoad")
    header_rows_to_skip: Optional[StrictInt] = Field(default=1, description="number of rows to skip (usually for headers)", alias="headerRowsToSkip")
    ignore_unknown_values: Optional[StrictBool] = Field(default=False, description="When enabled, rows with extra column values that do not match the schema will be ignored and will not be loaded into the table, rows with too few values will receive default value null", alias="ignoreUnknownValues")
    include_references: Optional[StrictBool] = Field(default=True, description="Include references", alias="includeReferences")
    include_data_reference: Optional[StrictBool] = Field(default=True, description="Include Data Reference", alias="includeDataReference")
    include_sample_reference: Optional[StrictBool] = Field(default=True, description="Include Sample Reference", alias="includeSampleReference")
    include_pipeline_reference: Optional[StrictBool] = Field(default=True, description="Include Pipeline Reference", alias="includePipelineReference")
    include_pipeline_execution_reference: Optional[StrictBool] = Field(default=True, description="Include Pipeline Execution Reference", alias="includePipelineExecutionReference")
    include_tenant_reference: Optional[StrictBool] = Field(default=True, description="Include Tenant Reference", alias="includeTenantReference")
    null_marker: Optional[StrictStr] = Field(default=None, description="Specifies a string that represents a null value in a CSV/TSV file.", alias="nullMarker")
    number_of_errors_allowed: Optional[StrictInt] = Field(default=0, description="The maximum number of bad records that Base can ignore when running the job", alias="numberOfErrorsAllowed")
    quote: Optional[StrictStr] = Field(default=None, description="The value that is used to quote data sections in a CSV/TSV file")
    write_preference: Optional[StrictStr] = Field(default='APPENDTOTABLE', description="specifies how to write data in the table.", alias="writePreference")
    __properties: ClassVar[List[str]] = ["allowQuotedNewlines", "dataId", "delimiter", "encoding", "forceLoad", "headerRowsToSkip", "ignoreUnknownValues", "includeReferences", "includeDataReference", "includeSampleReference", "includePipelineReference", "includePipelineExecutionReference", "includeTenantReference", "nullMarker", "numberOfErrorsAllowed", "quote", "writePreference"]

    @field_validator('encoding')
    def encoding_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['UTF8', 'ISO88591']):
            raise ValueError("must be one of enum values ('UTF8', 'ISO88591')")
        return value

    @field_validator('write_preference')
    def write_preference_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['WRITEIFEMPTY', 'APPENDTOTABLE', 'OVERWRITETABLE']):
            raise ValueError("must be one of enum values ('WRITEIFEMPTY', 'APPENDTOTABLE', 'OVERWRITETABLE')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of LoadDataInBaseRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if allow_quoted_newlines (nullable) is None
        # and model_fields_set contains the field
        if self.allow_quoted_newlines is None and "allow_quoted_newlines" in self.model_fields_set:
            _dict['allowQuotedNewlines'] = None

        # set to None if delimiter (nullable) is None
        # and model_fields_set contains the field
        if self.delimiter is None and "delimiter" in self.model_fields_set:
            _dict['delimiter'] = None

        # set to None if encoding (nullable) is None
        # and model_fields_set contains the field
        if self.encoding is None and "encoding" in self.model_fields_set:
            _dict['encoding'] = None

        # set to None if force_load (nullable) is None
        # and model_fields_set contains the field
        if self.force_load is None and "force_load" in self.model_fields_set:
            _dict['forceLoad'] = None

        # set to None if header_rows_to_skip (nullable) is None
        # and model_fields_set contains the field
        if self.header_rows_to_skip is None and "header_rows_to_skip" in self.model_fields_set:
            _dict['headerRowsToSkip'] = None

        # set to None if include_references (nullable) is None
        # and model_fields_set contains the field
        if self.include_references is None and "include_references" in self.model_fields_set:
            _dict['includeReferences'] = None

        # set to None if include_data_reference (nullable) is None
        # and model_fields_set contains the field
        if self.include_data_reference is None and "include_data_reference" in self.model_fields_set:
            _dict['includeDataReference'] = None

        # set to None if include_sample_reference (nullable) is None
        # and model_fields_set contains the field
        if self.include_sample_reference is None and "include_sample_reference" in self.model_fields_set:
            _dict['includeSampleReference'] = None

        # set to None if include_pipeline_reference (nullable) is None
        # and model_fields_set contains the field
        if self.include_pipeline_reference is None and "include_pipeline_reference" in self.model_fields_set:
            _dict['includePipelineReference'] = None

        # set to None if include_pipeline_execution_reference (nullable) is None
        # and model_fields_set contains the field
        if self.include_pipeline_execution_reference is None and "include_pipeline_execution_reference" in self.model_fields_set:
            _dict['includePipelineExecutionReference'] = None

        # set to None if include_tenant_reference (nullable) is None
        # and model_fields_set contains the field
        if self.include_tenant_reference is None and "include_tenant_reference" in self.model_fields_set:
            _dict['includeTenantReference'] = None

        # set to None if null_marker (nullable) is None
        # and model_fields_set contains the field
        if self.null_marker is None and "null_marker" in self.model_fields_set:
            _dict['nullMarker'] = None

        # set to None if number_of_errors_allowed (nullable) is None
        # and model_fields_set contains the field
        if self.number_of_errors_allowed is None and "number_of_errors_allowed" in self.model_fields_set:
            _dict['numberOfErrorsAllowed'] = None

        # set to None if quote (nullable) is None
        # and model_fields_set contains the field
        if self.quote is None and "quote" in self.model_fields_set:
            _dict['quote'] = None

        # set to None if write_preference (nullable) is None
        # and model_fields_set contains the field
        if self.write_preference is None and "write_preference" in self.model_fields_set:
            _dict['writePreference'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of LoadDataInBaseRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "allowQuotedNewlines": obj.get("allowQuotedNewlines") if obj.get("allowQuotedNewlines") is not None else False,
            "dataId": obj.get("dataId"),
            "delimiter": obj.get("delimiter") if obj.get("delimiter") is not None else ',',
            "encoding": obj.get("encoding") if obj.get("encoding") is not None else 'UTF8',
            "forceLoad": obj.get("forceLoad") if obj.get("forceLoad") is not None else False,
            "headerRowsToSkip": obj.get("headerRowsToSkip") if obj.get("headerRowsToSkip") is not None else 1,
            "ignoreUnknownValues": obj.get("ignoreUnknownValues") if obj.get("ignoreUnknownValues") is not None else False,
            "includeReferences": obj.get("includeReferences") if obj.get("includeReferences") is not None else True,
            "includeDataReference": obj.get("includeDataReference") if obj.get("includeDataReference") is not None else True,
            "includeSampleReference": obj.get("includeSampleReference") if obj.get("includeSampleReference") is not None else True,
            "includePipelineReference": obj.get("includePipelineReference") if obj.get("includePipelineReference") is not None else True,
            "includePipelineExecutionReference": obj.get("includePipelineExecutionReference") if obj.get("includePipelineExecutionReference") is not None else True,
            "includeTenantReference": obj.get("includeTenantReference") if obj.get("includeTenantReference") is not None else True,
            "nullMarker": obj.get("nullMarker"),
            "numberOfErrorsAllowed": obj.get("numberOfErrorsAllowed") if obj.get("numberOfErrorsAllowed") is not None else 0,
            "quote": obj.get("quote"),
            "writePreference": obj.get("writePreference") if obj.get("writePreference") is not None else 'APPENDTOTABLE'
        })
        return _obj

LoadDataInBaseRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var allow_quoted_newlines : bool | None

The type of the None singleton.

var data_id : str

The type of the None singleton.

var delimiter : str | None

The type of the None singleton.

var encoding : str | None

The type of the None singleton.

var force_load : bool | None

The type of the None singleton.

var header_rows_to_skip : int | None

The type of the None singleton.

var ignore_unknown_values : bool | None

The type of the None singleton.

var include_data_reference : bool | None

The type of the None singleton.

var include_pipeline_execution_reference : bool | None

The type of the None singleton.

var include_pipeline_reference : bool | None

The type of the None singleton.

var include_references : bool | None

The type of the None singleton.

var include_sample_reference : bool | None

The type of the None singleton.

var include_tenant_reference : bool | None

The type of the None singleton.

var model_config

The type of the None singleton.

var null_marker : str | None

The type of the None singleton.

var number_of_errors_allowed : int | None

The type of the None singleton.

var quote : str | None

The type of the None singleton.

var write_preference : str | None

The type of the None singleton.

Static methods

def encoding_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of LoadDataInBaseRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of LoadDataInBaseRequest from a JSON string

def write_preference_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if allow_quoted_newlines (nullable) is None
    # and model_fields_set contains the field
    if self.allow_quoted_newlines is None and "allow_quoted_newlines" in self.model_fields_set:
        _dict['allowQuotedNewlines'] = None

    # set to None if delimiter (nullable) is None
    # and model_fields_set contains the field
    if self.delimiter is None and "delimiter" in self.model_fields_set:
        _dict['delimiter'] = None

    # set to None if encoding (nullable) is None
    # and model_fields_set contains the field
    if self.encoding is None and "encoding" in self.model_fields_set:
        _dict['encoding'] = None

    # set to None if force_load (nullable) is None
    # and model_fields_set contains the field
    if self.force_load is None and "force_load" in self.model_fields_set:
        _dict['forceLoad'] = None

    # set to None if header_rows_to_skip (nullable) is None
    # and model_fields_set contains the field
    if self.header_rows_to_skip is None and "header_rows_to_skip" in self.model_fields_set:
        _dict['headerRowsToSkip'] = None

    # set to None if include_references (nullable) is None
    # and model_fields_set contains the field
    if self.include_references is None and "include_references" in self.model_fields_set:
        _dict['includeReferences'] = None

    # set to None if include_data_reference (nullable) is None
    # and model_fields_set contains the field
    if self.include_data_reference is None and "include_data_reference" in self.model_fields_set:
        _dict['includeDataReference'] = None

    # set to None if include_sample_reference (nullable) is None
    # and model_fields_set contains the field
    if self.include_sample_reference is None and "include_sample_reference" in self.model_fields_set:
        _dict['includeSampleReference'] = None

    # set to None if include_pipeline_reference (nullable) is None
    # and model_fields_set contains the field
    if self.include_pipeline_reference is None and "include_pipeline_reference" in self.model_fields_set:
        _dict['includePipelineReference'] = None

    # set to None if include_pipeline_execution_reference (nullable) is None
    # and model_fields_set contains the field
    if self.include_pipeline_execution_reference is None and "include_pipeline_execution_reference" in self.model_fields_set:
        _dict['includePipelineExecutionReference'] = None

    # set to None if include_tenant_reference (nullable) is None
    # and model_fields_set contains the field
    if self.include_tenant_reference is None and "include_tenant_reference" in self.model_fields_set:
        _dict['includeTenantReference'] = None

    # set to None if null_marker (nullable) is None
    # and model_fields_set contains the field
    if self.null_marker is None and "null_marker" in self.model_fields_set:
        _dict['nullMarker'] = None

    # set to None if number_of_errors_allowed (nullable) is None
    # and model_fields_set contains the field
    if self.number_of_errors_allowed is None and "number_of_errors_allowed" in self.model_fields_set:
        _dict['numberOfErrorsAllowed'] = None

    # set to None if quote (nullable) is None
    # and model_fields_set contains the field
    if self.quote is None and "quote" in self.model_fields_set:
        _dict['quote'] = None

    # set to None if write_preference (nullable) is None
    # and model_fields_set contains the field
    if self.write_preference is None and "write_preference" in self.model_fields_set:
        _dict['writePreference'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class MetadataField (**data: Any)

Expand source code

class MetadataField(BaseModel):
    """
    The metadata of the sample
    """ # noqa: E501
    id: StrictStr
    index: Optional[StrictInt] = None
    name: Optional[StrictStr] = None
    field_type: Optional[StrictStr] = Field(default=None, alias="fieldType")
    values: Optional[List[StrictStr]] = None
    group_values: Optional[List[MetadataField]] = Field(default=None, alias="groupValues")
    __properties: ClassVar[List[str]] = ["id", "index", "name", "fieldType", "values", "groupValues"]

    @field_validator('field_type')
    def field_type_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['TEXT', 'NUMERIC', 'BOOLEAN', 'DATE', 'GROUP']):
            raise ValueError("must be one of enum values ('TEXT', 'NUMERIC', 'BOOLEAN', 'DATE', 'GROUP')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of MetadataField from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in group_values (list)
        _items = []
        if self.group_values:
            for _item_group_values in self.group_values:
                if _item_group_values:
                    _items.append(_item_group_values.to_dict())
            _dict['groupValues'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of MetadataField from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "index": obj.get("index"),
            "name": obj.get("name"),
            "fieldType": obj.get("fieldType"),
            "values": obj.get("values"),
            "groupValues": [MetadataField.from_dict(_item) for _item in obj["groupValues"]] if obj.get("groupValues") is not None else None
        })
        return _obj

The metadata of the sample

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var field_type : str | None

The type of the None singleton.

var group_values : List[MetadataField] | None

The type of the None singleton.

var id : str

The type of the None singleton.

var index : int | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str | None

The type of the None singleton.

var values : List[str] | None

The type of the None singleton.

Static methods

def field_type_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of MetadataField from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of MetadataField from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in group_values (list)
    _items = []
    if self.group_values:
        for _item_group_values in self.group_values:
            if _item_group_values:
                _items.append(_item_group_values.to_dict())
        _dict['groupValues'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class MetadataModel (**data: Any)

Expand source code

class MetadataModel(BaseModel):
    """
    MetadataModel
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=1000)]] = None
    state: StrictStr
    parent_model_id: Optional[StrictStr] = Field(default=None, alias="parentModelId")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "description", "state", "parentModelId"]

    @field_validator('state')
    def state_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['DRAFT', 'PUBLISHED']):
            raise ValueError("must be one of enum values ('DRAFT', 'PUBLISHED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of MetadataModel from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if parent_model_id (nullable) is None
        # and model_fields_set contains the field
        if self.parent_model_id is None and "parent_model_id" in self.model_fields_set:
            _dict['parentModelId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of MetadataModel from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "description": obj.get("description"),
            "state": obj.get("state"),
            "parentModelId": obj.get("parentModelId")
        })
        return _obj

MetadataModel

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var parent_model_id : str | None

The type of the None singleton.

var state : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of MetadataModel from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of MetadataModel from a JSON string

def state_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if parent_model_id (nullable) is None
    # and model_fields_set contains the field
    if self.parent_model_id is None and "parent_model_id" in self.model_fields_set:
        _dict['parentModelId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class MetadataModelApi (api_client=None)

Expand source code

class MetadataModelApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_metadata_model(
        self,
        metadata_model_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> MetadataModel:
        """Retrieve a metadata model. Only metadata models that the user has access to can be retrieved.


        :param metadata_model_id: (required)
        :type metadata_model_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_metadata_model_serialize(
            metadata_model_id=metadata_model_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "MetadataModel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_metadata_model_with_http_info(
        self,
        metadata_model_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[MetadataModel]:
        """Retrieve a metadata model. Only metadata models that the user has access to can be retrieved.


        :param metadata_model_id: (required)
        :type metadata_model_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_metadata_model_serialize(
            metadata_model_id=metadata_model_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "MetadataModel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_metadata_model_without_preload_content(
        self,
        metadata_model_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a metadata model. Only metadata models that the user has access to can be retrieved.


        :param metadata_model_id: (required)
        :type metadata_model_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_metadata_model_serialize(
            metadata_model_id=metadata_model_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "MetadataModel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_metadata_model_serialize(
        self,
        metadata_model_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if metadata_model_id is not None:
            _path_params['metadataModelId'] = metadata_model_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/metadataModels/{metadataModelId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_metadata_model_fields(
        self,
        metadata_model_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> FieldList:
        """Retrieve the fields of a metadata model. Only metadata models that the user has access to can be retrieved.


        :param metadata_model_id: (required)
        :type metadata_model_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_metadata_model_fields_serialize(
            metadata_model_id=metadata_model_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "FieldList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_metadata_model_fields_with_http_info(
        self,
        metadata_model_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[FieldList]:
        """Retrieve the fields of a metadata model. Only metadata models that the user has access to can be retrieved.


        :param metadata_model_id: (required)
        :type metadata_model_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_metadata_model_fields_serialize(
            metadata_model_id=metadata_model_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "FieldList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_metadata_model_fields_without_preload_content(
        self,
        metadata_model_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the fields of a metadata model. Only metadata models that the user has access to can be retrieved.


        :param metadata_model_id: (required)
        :type metadata_model_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_metadata_model_fields_serialize(
            metadata_model_id=metadata_model_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "FieldList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_metadata_model_fields_serialize(
        self,
        metadata_model_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if metadata_model_id is not None:
            _path_params['metadataModelId'] = metadata_model_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/metadataModels/{metadataModelId}/fields',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_metadata_models(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> MetadataModelList:
        """Retrieve the metadata models for the tenant associated to the security context.

        Retrieve the metadata models for the tenant associated to the security context. This call returns a list of metadata models for the tenant in a non-hierarchical way. Instead of a model having a list of child models all models except the root model have a parent model identifier. This can be used to reconstruct the hierarchy.

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_metadata_models_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "MetadataModelList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_metadata_models_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[MetadataModelList]:
        """Retrieve the metadata models for the tenant associated to the security context.

        Retrieve the metadata models for the tenant associated to the security context. This call returns a list of metadata models for the tenant in a non-hierarchical way. Instead of a model having a list of child models all models except the root model have a parent model identifier. This can be used to reconstruct the hierarchy.

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_metadata_models_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "MetadataModelList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_metadata_models_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the metadata models for the tenant associated to the security context.

        Retrieve the metadata models for the tenant associated to the security context. This call returns a list of metadata models for the tenant in a non-hierarchical way. Instead of a model having a list of child models all models except the root model have a parent model identifier. This can be used to reconstruct the hierarchy.

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_metadata_models_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "MetadataModelList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_metadata_models_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/metadataModels',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_tenant_model(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Model:
        """Retrieve the tenant model for the tenant associated to the security context.

        Retrieve the tenant model for the tenant associated to the security context. The tenant model is a hierarchical structure where the top level tenant holds a list of child models (which in turn can hold child models).

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_tenant_model_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Model",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_tenant_model_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Model]:
        """Retrieve the tenant model for the tenant associated to the security context.

        Retrieve the tenant model for the tenant associated to the security context. The tenant model is a hierarchical structure where the top level tenant holds a list of child models (which in turn can hold child models).

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_tenant_model_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Model",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_tenant_model_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the tenant model for the tenant associated to the security context.

        Retrieve the tenant model for the tenant associated to the security context. The tenant model is a hierarchical structure where the top level tenant holds a list of child models (which in turn can hold child models).

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_tenant_model_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Model",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_tenant_model_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/metadataModels/tenantModel',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_metadata_model(self, metadata_model_id: Annotated[str, Strict(strict=True)]) ‑> MetadataModel

Expand source code

@validate_call
def get_metadata_model(
    self,
    metadata_model_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> MetadataModel:
    """Retrieve a metadata model. Only metadata models that the user has access to can be retrieved.


    :param metadata_model_id: (required)
    :type metadata_model_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_metadata_model_serialize(
        metadata_model_id=metadata_model_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "MetadataModel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a metadata model. Only metadata models that the user has access to can be retrieved.

:param metadata_model_id: (required) :type metadata_model_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_metadata_model_fields(self, metadata_model_id: Annotated[str, Strict(strict=True)]) ‑> FieldList

Expand source code

@validate_call
def get_metadata_model_fields(
    self,
    metadata_model_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> FieldList:
    """Retrieve the fields of a metadata model. Only metadata models that the user has access to can be retrieved.


    :param metadata_model_id: (required)
    :type metadata_model_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_metadata_model_fields_serialize(
        metadata_model_id=metadata_model_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "FieldList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the fields of a metadata model. Only metadata models that the user has access to can be retrieved.

:param metadata_model_id: (required) :type metadata_model_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_metadata_model_fields_with_http_info(self, metadata_model_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[FieldList]

Expand source code

@validate_call
def get_metadata_model_fields_with_http_info(
    self,
    metadata_model_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[FieldList]:
    """Retrieve the fields of a metadata model. Only metadata models that the user has access to can be retrieved.


    :param metadata_model_id: (required)
    :type metadata_model_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_metadata_model_fields_serialize(
        metadata_model_id=metadata_model_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "FieldList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the fields of a metadata model. Only metadata models that the user has access to can be retrieved.

:param metadata_model_id: (required) :type metadata_model_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_metadata_model_fields_without_preload_content(self, metadata_model_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_metadata_model_fields_without_preload_content(
    self,
    metadata_model_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the fields of a metadata model. Only metadata models that the user has access to can be retrieved.


    :param metadata_model_id: (required)
    :type metadata_model_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_metadata_model_fields_serialize(
        metadata_model_id=metadata_model_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "FieldList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the fields of a metadata model. Only metadata models that the user has access to can be retrieved.

:param metadata_model_id: (required) :type metadata_model_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_metadata_model_with_http_info(self, metadata_model_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[MetadataModel]

Expand source code

@validate_call
def get_metadata_model_with_http_info(
    self,
    metadata_model_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[MetadataModel]:
    """Retrieve a metadata model. Only metadata models that the user has access to can be retrieved.


    :param metadata_model_id: (required)
    :type metadata_model_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_metadata_model_serialize(
        metadata_model_id=metadata_model_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "MetadataModel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a metadata model. Only metadata models that the user has access to can be retrieved.

:param metadata_model_id: (required) :type metadata_model_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_metadata_model_without_preload_content(self, metadata_model_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_metadata_model_without_preload_content(
    self,
    metadata_model_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a metadata model. Only metadata models that the user has access to can be retrieved.


    :param metadata_model_id: (required)
    :type metadata_model_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_metadata_model_serialize(
        metadata_model_id=metadata_model_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "MetadataModel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a metadata model. Only metadata models that the user has access to can be retrieved.

:param metadata_model_id: (required) :type metadata_model_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_metadata_models(self) ‑> MetadataModelList

Expand source code

@validate_call
def get_metadata_models(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> MetadataModelList:
    """Retrieve the metadata models for the tenant associated to the security context.

    Retrieve the metadata models for the tenant associated to the security context. This call returns a list of metadata models for the tenant in a non-hierarchical way. Instead of a model having a list of child models all models except the root model have a parent model identifier. This can be used to reconstruct the hierarchy.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_metadata_models_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "MetadataModelList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the metadata models for the tenant associated to the security context.

Retrieve the metadata models for the tenant associated to the security context. This call returns a list of metadata models for the tenant in a non-hierarchical way. Instead of a model having a list of child models all models except the root model have a parent model identifier. This can be used to reconstruct the hierarchy.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_metadata_models_with_http_info(self) ‑> ApiResponse[MetadataModelList]

Expand source code

@validate_call
def get_metadata_models_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[MetadataModelList]:
    """Retrieve the metadata models for the tenant associated to the security context.

    Retrieve the metadata models for the tenant associated to the security context. This call returns a list of metadata models for the tenant in a non-hierarchical way. Instead of a model having a list of child models all models except the root model have a parent model identifier. This can be used to reconstruct the hierarchy.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_metadata_models_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "MetadataModelList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the metadata models for the tenant associated to the security context.

Retrieve the metadata models for the tenant associated to the security context. This call returns a list of metadata models for the tenant in a non-hierarchical way. Instead of a model having a list of child models all models except the root model have a parent model identifier. This can be used to reconstruct the hierarchy.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_metadata_models_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_metadata_models_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the metadata models for the tenant associated to the security context.

    Retrieve the metadata models for the tenant associated to the security context. This call returns a list of metadata models for the tenant in a non-hierarchical way. Instead of a model having a list of child models all models except the root model have a parent model identifier. This can be used to reconstruct the hierarchy.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_metadata_models_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "MetadataModelList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the metadata models for the tenant associated to the security context.

Retrieve the metadata models for the tenant associated to the security context. This call returns a list of metadata models for the tenant in a non-hierarchical way. Instead of a model having a list of child models all models except the root model have a parent model identifier. This can be used to reconstruct the hierarchy.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_tenant_model(self) ‑> Model

Expand source code

@validate_call
def get_tenant_model(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Model:
    """Retrieve the tenant model for the tenant associated to the security context.

    Retrieve the tenant model for the tenant associated to the security context. The tenant model is a hierarchical structure where the top level tenant holds a list of child models (which in turn can hold child models).

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_tenant_model_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Model",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the tenant model for the tenant associated to the security context.

Retrieve the tenant model for the tenant associated to the security context. The tenant model is a hierarchical structure where the top level tenant holds a list of child models (which in turn can hold child models).

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_tenant_model_with_http_info(self) ‑> ApiResponse[Model]

Expand source code

@validate_call
def get_tenant_model_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Model]:
    """Retrieve the tenant model for the tenant associated to the security context.

    Retrieve the tenant model for the tenant associated to the security context. The tenant model is a hierarchical structure where the top level tenant holds a list of child models (which in turn can hold child models).

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_tenant_model_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Model",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the tenant model for the tenant associated to the security context.

Retrieve the tenant model for the tenant associated to the security context. The tenant model is a hierarchical structure where the top level tenant holds a list of child models (which in turn can hold child models).

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_tenant_model_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_tenant_model_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the tenant model for the tenant associated to the security context.

    Retrieve the tenant model for the tenant associated to the security context. The tenant model is a hierarchical structure where the top level tenant holds a list of child models (which in turn can hold child models).

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_tenant_model_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Model",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the tenant model for the tenant associated to the security context.

Retrieve the tenant model for the tenant associated to the security context. The tenant model is a hierarchical structure where the top level tenant holds a list of child models (which in turn can hold child models).

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class MetadataModelList (**data: Any)

Expand source code

class MetadataModelList(BaseModel):
    """
    MetadataModelList
    """ # noqa: E501
    items: List[Optional[MetadataModel]]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of MetadataModelList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of MetadataModelList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [MetadataModel.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

MetadataModelList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[MetadataModel | None]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of MetadataModelList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of MetadataModelList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Model (**data: Any)

Expand source code

class Model(BaseModel):
    """
    Model
    """ # noqa: E501
    id: StrictStr
    name: Optional[StrictStr] = None
    description: Optional[StrictStr] = None
    state: Optional[StrictStr] = None
    models: Optional[List[Model]] = None
    fields: Optional[List[Optional[ModelField]]] = None
    __properties: ClassVar[List[str]] = ["id", "name", "description", "state", "models", "fields"]

    @field_validator('state')
    def state_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['DRAFT', 'PUBLISHED']):
            raise ValueError("must be one of enum values ('DRAFT', 'PUBLISHED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Model from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in models (list)
        _items = []
        if self.models:
            for _item_models in self.models:
                if _item_models:
                    _items.append(_item_models.to_dict())
            _dict['models'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
        _items = []
        if self.fields:
            for _item_fields in self.fields:
                if _item_fields:
                    _items.append(_item_fields.to_dict())
            _dict['fields'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Model from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name"),
            "description": obj.get("description"),
            "state": obj.get("state"),
            "models": [Model.from_dict(_item) for _item in obj["models"]] if obj.get("models") is not None else None,
            "fields": [ModelField.from_dict(_item) for _item in obj["fields"]] if obj.get("fields") is not None else None
        })
        return _obj

Model

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var fields : List[ModelField | None] | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var models : List[Model] | None

The type of the None singleton.

var name : str | None

The type of the None singleton.

var state : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Model from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Model from a JSON string

def state_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in models (list)
    _items = []
    if self.models:
        for _item_models in self.models:
            if _item_models:
                _items.append(_item_models.to_dict())
        _dict['models'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
    _items = []
    if self.fields:
        for _item_fields in self.fields:
            if _item_fields:
                _items.append(_item_fields.to_dict())
        _dict['fields'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ModelField (**data: Any)

Expand source code

class ModelField(BaseModel):
    """
    ModelField
    """ # noqa: E501
    id: StrictStr
    name: Optional[StrictStr] = None
    description: Optional[StrictStr] = None
    field_type: Optional[StrictStr] = Field(default=None, alias="fieldType")
    required: Optional[StrictBool] = None
    multivalued: Optional[StrictBool] = None
    filled_by_pipeline: Optional[StrictBool] = Field(default=None, alias="filledByPipeline")
    fields: Optional[List[Optional[ModelField]]] = None
    enumeration_values: Optional[List[StrictStr]] = Field(default=None, alias="enumerationValues")
    __properties: ClassVar[List[str]] = ["id", "name", "description", "fieldType", "required", "multivalued", "filledByPipeline", "fields", "enumerationValues"]

    @field_validator('field_type')
    def field_type_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['TEXT', 'NUMERIC', 'BOOLEAN', 'DATE', 'ENUMERATION', 'FIELDGROUP', 'PIPELINE_REFERENCE']):
            raise ValueError("must be one of enum values ('TEXT', 'NUMERIC', 'BOOLEAN', 'DATE', 'ENUMERATION', 'FIELDGROUP', 'PIPELINE_REFERENCE')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ModelField from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
        _items = []
        if self.fields:
            for _item_fields in self.fields:
                if _item_fields:
                    _items.append(_item_fields.to_dict())
            _dict['fields'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ModelField from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name"),
            "description": obj.get("description"),
            "fieldType": obj.get("fieldType"),
            "required": obj.get("required"),
            "multivalued": obj.get("multivalued"),
            "filledByPipeline": obj.get("filledByPipeline"),
            "fields": [ModelField.from_dict(_item) for _item in obj["fields"]] if obj.get("fields") is not None else None,
            "enumerationValues": obj.get("enumerationValues")
        })
        return _obj

ModelField

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var enumeration_values : List[str] | None

The type of the None singleton.

var field_type : str | None

The type of the None singleton.

var fields : List[ModelField | None] | None

The type of the None singleton.

var filled_by_pipeline : bool | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var multivalued : bool | None

The type of the None singleton.

var name : str | None

The type of the None singleton.

var required : bool | None

The type of the None singleton.

Static methods

def field_type_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ModelField from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ModelField from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
    _items = []
    if self.fields:
        for _item_fields in self.fields:
            if _item_fields:
                _items.append(_item_fields.to_dict())
        _dict['fields'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class MultipartFormDataInput (**data: Any)

Expand source code

class MultipartFormDataInput(BaseModel):
    """
    MultipartFormDataInput
    """ # noqa: E501
    form_data: Optional[Dict[str, InputPart]] = Field(default=None, alias="formData")
    form_data_map: Optional[Dict[str, List[InputPart]]] = Field(default=None, alias="formDataMap")
    preamble: Optional[StrictStr] = None
    parts: Optional[List[InputPart]] = None
    __properties: ClassVar[List[str]] = ["formData", "formDataMap", "preamble", "parts"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of MultipartFormDataInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each value in form_data (dict)
        _field_dict = {}
        if self.form_data:
            for _key_form_data in self.form_data:
                if self.form_data[_key_form_data]:
                    _field_dict[_key_form_data] = self.form_data[_key_form_data].to_dict()
            _dict['formData'] = _field_dict
        # override the default output from pydantic by calling `to_dict()` of each value in form_data_map (dict of array)
        _field_dict_of_array = {}
        if self.form_data_map:
            for _key_form_data_map in self.form_data_map:
                if self.form_data_map[_key_form_data_map] is not None:
                    _field_dict_of_array[_key_form_data_map] = [
                        _item.to_dict() for _item in self.form_data_map[_key_form_data_map]
                    ]
            _dict['formDataMap'] = _field_dict_of_array
        # override the default output from pydantic by calling `to_dict()` of each item in parts (list)
        _items = []
        if self.parts:
            for _item_parts in self.parts:
                if _item_parts:
                    _items.append(_item_parts.to_dict())
            _dict['parts'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of MultipartFormDataInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "formData": dict(
                (_k, InputPart.from_dict(_v))
                for _k, _v in obj["formData"].items()
            )
            if obj.get("formData") is not None
            else None,
            "formDataMap": dict(
                (_k,
                        [InputPart.from_dict(_item) for _item in _v]
                        if _v is not None
                        else None
                )
                for _k, _v in obj.get("formDataMap", {}).items()
            ),
            "preamble": obj.get("preamble"),
            "parts": [InputPart.from_dict(_item) for _item in obj["parts"]] if obj.get("parts") is not None else None
        })
        return _obj

MultipartFormDataInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var form_data : Dict[str, InputPart] | None

The type of the None singleton.

var form_data_map : Dict[str, List[InputPart]] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var parts : List[InputPart] | None

The type of the None singleton.

var preamble : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of MultipartFormDataInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of MultipartFormDataInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each value in form_data (dict)
    _field_dict = {}
    if self.form_data:
        for _key_form_data in self.form_data:
            if self.form_data[_key_form_data]:
                _field_dict[_key_form_data] = self.form_data[_key_form_data].to_dict()
        _dict['formData'] = _field_dict
    # override the default output from pydantic by calling `to_dict()` of each value in form_data_map (dict of array)
    _field_dict_of_array = {}
    if self.form_data_map:
        for _key_form_data_map in self.form_data_map:
            if self.form_data_map[_key_form_data_map] is not None:
                _field_dict_of_array[_key_form_data_map] = [
                    _item.to_dict() for _item in self.form_data_map[_key_form_data_map]
                ]
        _dict['formDataMap'] = _field_dict_of_array
    # override the default output from pydantic by calling `to_dict()` of each item in parts (list)
    _items = []
    if self.parts:
        for _item_parts in self.parts:
            if _item_parts:
                _items.append(_item_parts.to_dict())
        _dict['parts'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class NextflowAnalysisInput (**data: Any)

Expand source code

class NextflowAnalysisInput(BaseModel):
    """
    NextflowAnalysisInput
    """ # noqa: E501
    inputs: List[AnalysisDataInput]
    parameters: Optional[List[Optional[AnalysisParameterInput]]] = None
    reference_data_parameters: Optional[List[Optional[AnalysisReferenceDataParameter]]] = Field(default=None, alias="referenceDataParameters")
    __properties: ClassVar[List[str]] = ["inputs", "parameters", "referenceDataParameters"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of NextflowAnalysisInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in inputs (list)
        _items = []
        if self.inputs:
            for _item_inputs in self.inputs:
                if _item_inputs:
                    _items.append(_item_inputs.to_dict())
            _dict['inputs'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in parameters (list)
        _items = []
        if self.parameters:
            for _item_parameters in self.parameters:
                if _item_parameters:
                    _items.append(_item_parameters.to_dict())
            _dict['parameters'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in reference_data_parameters (list)
        _items = []
        if self.reference_data_parameters:
            for _item_reference_data_parameters in self.reference_data_parameters:
                if _item_reference_data_parameters:
                    _items.append(_item_reference_data_parameters.to_dict())
            _dict['referenceDataParameters'] = _items
        # set to None if parameters (nullable) is None
        # and model_fields_set contains the field
        if self.parameters is None and "parameters" in self.model_fields_set:
            _dict['parameters'] = None

        # set to None if reference_data_parameters (nullable) is None
        # and model_fields_set contains the field
        if self.reference_data_parameters is None and "reference_data_parameters" in self.model_fields_set:
            _dict['referenceDataParameters'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of NextflowAnalysisInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "inputs": [AnalysisDataInput.from_dict(_item) for _item in obj["inputs"]] if obj.get("inputs") is not None else None,
            "parameters": [AnalysisParameterInput.from_dict(_item) for _item in obj["parameters"]] if obj.get("parameters") is not None else None,
            "referenceDataParameters": [AnalysisReferenceDataParameter.from_dict(_item) for _item in obj["referenceDataParameters"]] if obj.get("referenceDataParameters") is not None else None
        })
        return _obj

NextflowAnalysisInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var inputs : List[AnalysisDataInput]

The type of the None singleton.

var model_config

The type of the None singleton.

var parameters : List[AnalysisParameterInput | None] | None

The type of the None singleton.

var reference_data_parameters : List[AnalysisReferenceDataParameter | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of NextflowAnalysisInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of NextflowAnalysisInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in inputs (list)
    _items = []
    if self.inputs:
        for _item_inputs in self.inputs:
            if _item_inputs:
                _items.append(_item_inputs.to_dict())
        _dict['inputs'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in parameters (list)
    _items = []
    if self.parameters:
        for _item_parameters in self.parameters:
            if _item_parameters:
                _items.append(_item_parameters.to_dict())
        _dict['parameters'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in reference_data_parameters (list)
    _items = []
    if self.reference_data_parameters:
        for _item_reference_data_parameters in self.reference_data_parameters:
            if _item_reference_data_parameters:
                _items.append(_item_reference_data_parameters.to_dict())
        _dict['referenceDataParameters'] = _items
    # set to None if parameters (nullable) is None
    # and model_fields_set contains the field
    if self.parameters is None and "parameters" in self.model_fields_set:
        _dict['parameters'] = None

    # set to None if reference_data_parameters (nullable) is None
    # and model_fields_set contains the field
    if self.reference_data_parameters is None and "reference_data_parameters" in self.model_fields_set:
        _dict['referenceDataParameters'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class NextflowAnalysisWithCustomInput (**data: Any)

Expand source code

class NextflowAnalysisWithCustomInput(BaseModel):
    """
    NextflowAnalysisWithCustomInput
    """ # noqa: E501
    custom_input: StrictStr = Field(description="Contains the custom input, in YAML format or as an escaped JSON string.", alias="customInput")
    data_ids: Optional[List[StrictStr]] = Field(default=None, alias="dataIds")
    mounts: Optional[List[Optional[AnalysisInputDataMount]]] = None
    external_data: Optional[List[Optional[AnalysisInputExternalData]]] = Field(default=None, alias="externalData")
    __properties: ClassVar[List[str]] = ["customInput", "dataIds", "mounts", "externalData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of NextflowAnalysisWithCustomInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in mounts (list)
        _items = []
        if self.mounts:
            for _item_mounts in self.mounts:
                if _item_mounts:
                    _items.append(_item_mounts.to_dict())
            _dict['mounts'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
        _items = []
        if self.external_data:
            for _item_external_data in self.external_data:
                if _item_external_data:
                    _items.append(_item_external_data.to_dict())
            _dict['externalData'] = _items
        # set to None if mounts (nullable) is None
        # and model_fields_set contains the field
        if self.mounts is None and "mounts" in self.model_fields_set:
            _dict['mounts'] = None

        # set to None if external_data (nullable) is None
        # and model_fields_set contains the field
        if self.external_data is None and "external_data" in self.model_fields_set:
            _dict['externalData'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of NextflowAnalysisWithCustomInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "customInput": obj.get("customInput"),
            "dataIds": obj.get("dataIds"),
            "mounts": [AnalysisInputDataMount.from_dict(_item) for _item in obj["mounts"]] if obj.get("mounts") is not None else None,
            "externalData": [AnalysisInputExternalData.from_dict(_item) for _item in obj["externalData"]] if obj.get("externalData") is not None else None
        })
        return _obj

NextflowAnalysisWithCustomInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var custom_input : str

The type of the None singleton.

var data_ids : List[str] | None

The type of the None singleton.

var external_data : List[AnalysisInputExternalData | None] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var mounts : List[AnalysisInputDataMount | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of NextflowAnalysisWithCustomInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of NextflowAnalysisWithCustomInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in mounts (list)
    _items = []
    if self.mounts:
        for _item_mounts in self.mounts:
            if _item_mounts:
                _items.append(_item_mounts.to_dict())
        _dict['mounts'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
    _items = []
    if self.external_data:
        for _item_external_data in self.external_data:
            if _item_external_data:
                _items.append(_item_external_data.to_dict())
        _dict['externalData'] = _items
    # set to None if mounts (nullable) is None
    # and model_fields_set contains the field
    if self.mounts is None and "mounts" in self.model_fields_set:
        _dict['mounts'] = None

    # set to None if external_data (nullable) is None
    # and model_fields_set contains the field
    if self.external_data is None and "external_data" in self.model_fields_set:
        _dict['externalData'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class NextflowJsonAnalysisInput (**data: Any)

Expand source code

class NextflowJsonAnalysisInput(BaseModel):
    """
    NextflowJsonAnalysisInput
    """ # noqa: E501
    fields: Optional[List[InputFormFieldValues]] = None
    groups: Optional[List[InputFormGroup]] = None
    __properties: ClassVar[List[str]] = ["fields", "groups"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of NextflowJsonAnalysisInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
        _items = []
        if self.fields:
            for _item_fields in self.fields:
                if _item_fields:
                    _items.append(_item_fields.to_dict())
            _dict['fields'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in groups (list)
        _items = []
        if self.groups:
            for _item_groups in self.groups:
                if _item_groups:
                    _items.append(_item_groups.to_dict())
            _dict['groups'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of NextflowJsonAnalysisInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "fields": [InputFormFieldValues.from_dict(_item) for _item in obj["fields"]] if obj.get("fields") is not None else None,
            "groups": [InputFormGroup.from_dict(_item) for _item in obj["groups"]] if obj.get("groups") is not None else None
        })
        return _obj

NextflowJsonAnalysisInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var fields : List[InputFormFieldValues] | None

The type of the None singleton.

var groups : List[InputFormGroup] | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of NextflowJsonAnalysisInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of NextflowJsonAnalysisInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in fields (list)
    _items = []
    if self.fields:
        for _item_fields in self.fields:
            if _item_fields:
                _items.append(_item_fields.to_dict())
        _dict['fields'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in groups (list)
    _items = []
    if self.groups:
        for _item_groups in self.groups:
            if _item_groups:
                _items.append(_item_groups.to_dict())
        _dict['groups'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class NotificationChannel (**data: Any)

Expand source code

class NotificationChannel(BaseModel):
    """
    NotificationChannel
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    enabled: StrictBool = Field(description="Should this channel be enabled or not?")
    type: StrictStr = Field(description="The type of delivery target (MAIL, SQS, SNS, HTTP, ...)")
    address: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The address where to send a notification to (email address, url, ...)")
    aws_region: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = Field(default=None, description="The AWS region of the SNS notification channel", alias="awsRegion")
    application: Optional[ApplicationV4] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "enabled", "type", "address", "awsRegion", "application"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['MAIL', 'SQS', 'SNS', 'HTTP']):
            raise ValueError("must be one of enum values ('MAIL', 'SQS', 'SNS', 'HTTP')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of NotificationChannel from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if aws_region (nullable) is None
        # and model_fields_set contains the field
        if self.aws_region is None and "aws_region" in self.model_fields_set:
            _dict['awsRegion'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of NotificationChannel from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "enabled": obj.get("enabled"),
            "type": obj.get("type"),
            "address": obj.get("address"),
            "awsRegion": obj.get("awsRegion"),
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None
        })
        return _obj

NotificationChannel

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var address : str

The type of the None singleton.

var application : ApplicationV4 | None

The type of the None singleton.

var aws_region : str | None

The type of the None singleton.

var enabled : bool

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of NotificationChannel from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of NotificationChannel from a JSON string

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if aws_region (nullable) is None
    # and model_fields_set contains the field
    if self.aws_region is None and "aws_region" in self.model_fields_set:
        _dict['awsRegion'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class NotificationChannelApi (api_client=None)

Expand source code

class NotificationChannelApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_notification_channel(
        self,
        create_notification_channel: Annotated[CreateNotificationChannel, Field(description="The new channel")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationChannel:
        """Create a notification channel


        :param create_notification_channel: The new channel (required)
        :type create_notification_channel: CreateNotificationChannel
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_notification_channel_serialize(
            create_notification_channel=create_notification_channel,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "NotificationChannel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_notification_channel_with_http_info(
        self,
        create_notification_channel: Annotated[CreateNotificationChannel, Field(description="The new channel")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationChannel]:
        """Create a notification channel


        :param create_notification_channel: The new channel (required)
        :type create_notification_channel: CreateNotificationChannel
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_notification_channel_serialize(
            create_notification_channel=create_notification_channel,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "NotificationChannel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_notification_channel_without_preload_content(
        self,
        create_notification_channel: Annotated[CreateNotificationChannel, Field(description="The new channel")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a notification channel


        :param create_notification_channel: The new channel (required)
        :type create_notification_channel: CreateNotificationChannel
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_notification_channel_serialize(
            create_notification_channel=create_notification_channel,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "NotificationChannel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_notification_channel_serialize(
        self,
        create_notification_channel,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_notification_channel is not None:
            _body_params = create_notification_channel


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/notificationChannels',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_notification_channel(
        self,
        channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to delete")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a notification channel


        :param channel_id: The ID of the notification channel to delete (required)
        :type channel_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_notification_channel_serialize(
            channel_id=channel_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_notification_channel_with_http_info(
        self,
        channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to delete")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a notification channel


        :param channel_id: The ID of the notification channel to delete (required)
        :type channel_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_notification_channel_serialize(
            channel_id=channel_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_notification_channel_without_preload_content(
        self,
        channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to delete")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a notification channel


        :param channel_id: The ID of the notification channel to delete (required)
        :type channel_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_notification_channel_serialize(
            channel_id=channel_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_notification_channel_serialize(
        self,
        channel_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if channel_id is not None:
            _path_params['channelId'] = channel_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/notificationChannels/{channelId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_notification_channel(
        self,
        channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationChannel:
        """Retrieve a notification channel


        :param channel_id: The ID of the notification channel to retrieve (required)
        :type channel_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_channel_serialize(
            channel_id=channel_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationChannel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_notification_channel_with_http_info(
        self,
        channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationChannel]:
        """Retrieve a notification channel


        :param channel_id: The ID of the notification channel to retrieve (required)
        :type channel_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_channel_serialize(
            channel_id=channel_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationChannel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_notification_channel_without_preload_content(
        self,
        channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a notification channel


        :param channel_id: The ID of the notification channel to retrieve (required)
        :type channel_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_channel_serialize(
            channel_id=channel_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationChannel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_notification_channel_serialize(
        self,
        channel_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if channel_id is not None:
            _path_params['channelId'] = channel_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/notificationChannels/{channelId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_notification_channels(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationChannelList:
        """Retrieve notification channels


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_channels_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationChannelList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_notification_channels_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationChannelList]:
        """Retrieve notification channels


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_channels_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationChannelList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_notification_channels_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve notification channels


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_channels_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationChannelList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_notification_channels_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/notificationChannels',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_notification_channel(
        self,
        channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to update")],
        notification_channel: Annotated[NotificationChannel, Field(description="The updated channel")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationChannel:
        """Update a notification channel

        This will affect all subscriptions which use this address!Fields which can be updated:  - enabled  - address  - awsRegion 

        :param channel_id: The ID of the notification channel to update (required)
        :type channel_id: str
        :param notification_channel: The updated channel (required)
        :type notification_channel: NotificationChannel
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_notification_channel_serialize(
            channel_id=channel_id,
            notification_channel=notification_channel,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationChannel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_notification_channel_with_http_info(
        self,
        channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to update")],
        notification_channel: Annotated[NotificationChannel, Field(description="The updated channel")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationChannel]:
        """Update a notification channel

        This will affect all subscriptions which use this address!Fields which can be updated:  - enabled  - address  - awsRegion 

        :param channel_id: The ID of the notification channel to update (required)
        :type channel_id: str
        :param notification_channel: The updated channel (required)
        :type notification_channel: NotificationChannel
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_notification_channel_serialize(
            channel_id=channel_id,
            notification_channel=notification_channel,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationChannel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_notification_channel_without_preload_content(
        self,
        channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to update")],
        notification_channel: Annotated[NotificationChannel, Field(description="The updated channel")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a notification channel

        This will affect all subscriptions which use this address!Fields which can be updated:  - enabled  - address  - awsRegion 

        :param channel_id: The ID of the notification channel to update (required)
        :type channel_id: str
        :param notification_channel: The updated channel (required)
        :type notification_channel: NotificationChannel
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_notification_channel_serialize(
            channel_id=channel_id,
            notification_channel=notification_channel,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationChannel",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_notification_channel_serialize(
        self,
        channel_id,
        notification_channel,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if channel_id is not None:
            _path_params['channelId'] = channel_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if notification_channel is not None:
            _body_params = notification_channel


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/notificationChannels/{channelId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_notification_channel(self,
create_notification_channel: Annotated[CreateNotificationChannel, FieldInfo(annotation=NoneType, required=True, description='The new channel')]) ‑> NotificationChannel

Expand source code

@validate_call
def create_notification_channel(
    self,
    create_notification_channel: Annotated[CreateNotificationChannel, Field(description="The new channel")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> NotificationChannel:
    """Create a notification channel


    :param create_notification_channel: The new channel (required)
    :type create_notification_channel: CreateNotificationChannel
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_notification_channel_serialize(
        create_notification_channel=create_notification_channel,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "NotificationChannel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a notification channel

:param create_notification_channel: The new channel (required) :type create_notification_channel: CreateNotificationChannel :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_notification_channel_with_http_info(self,
create_notification_channel: Annotated[CreateNotificationChannel, FieldInfo(annotation=NoneType, required=True, description='The new channel')]) ‑> ApiResponse[NotificationChannel]

Expand source code

@validate_call
def create_notification_channel_with_http_info(
    self,
    create_notification_channel: Annotated[CreateNotificationChannel, Field(description="The new channel")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[NotificationChannel]:
    """Create a notification channel


    :param create_notification_channel: The new channel (required)
    :type create_notification_channel: CreateNotificationChannel
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_notification_channel_serialize(
        create_notification_channel=create_notification_channel,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "NotificationChannel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a notification channel

:param create_notification_channel: The new channel (required) :type create_notification_channel: CreateNotificationChannel :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_notification_channel_without_preload_content(self,
create_notification_channel: Annotated[CreateNotificationChannel, FieldInfo(annotation=NoneType, required=True, description='The new channel')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_notification_channel_without_preload_content(
    self,
    create_notification_channel: Annotated[CreateNotificationChannel, Field(description="The new channel")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a notification channel


    :param create_notification_channel: The new channel (required)
    :type create_notification_channel: CreateNotificationChannel
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_notification_channel_serialize(
        create_notification_channel=create_notification_channel,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "NotificationChannel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a notification channel

:param create_notification_channel: The new channel (required) :type create_notification_channel: CreateNotificationChannel :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_notification_channel(self,
channel_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification channel to delete')]) ‑> None

Expand source code

@validate_call
def delete_notification_channel(
    self,
    channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to delete")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete a notification channel


    :param channel_id: The ID of the notification channel to delete (required)
    :type channel_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_notification_channel_serialize(
        channel_id=channel_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete a notification channel

:param channel_id: The ID of the notification channel to delete (required) :type channel_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_notification_channel_with_http_info(self,
channel_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification channel to delete')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_notification_channel_with_http_info(
    self,
    channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to delete")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete a notification channel


    :param channel_id: The ID of the notification channel to delete (required)
    :type channel_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_notification_channel_serialize(
        channel_id=channel_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete a notification channel

:param channel_id: The ID of the notification channel to delete (required) :type channel_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_notification_channel_without_preload_content(self,
channel_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification channel to delete')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_notification_channel_without_preload_content(
    self,
    channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to delete")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete a notification channel


    :param channel_id: The ID of the notification channel to delete (required)
    :type channel_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_notification_channel_serialize(
        channel_id=channel_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete a notification channel

:param channel_id: The ID of the notification channel to delete (required) :type channel_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_channel(self,
channel_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification channel to retrieve')]) ‑> NotificationChannel

Expand source code

@validate_call
def get_notification_channel(
    self,
    channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> NotificationChannel:
    """Retrieve a notification channel


    :param channel_id: The ID of the notification channel to retrieve (required)
    :type channel_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_channel_serialize(
        channel_id=channel_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationChannel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a notification channel

:param channel_id: The ID of the notification channel to retrieve (required) :type channel_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_channel_with_http_info(self,
channel_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification channel to retrieve')]) ‑> ApiResponse[NotificationChannel]

Expand source code

@validate_call
def get_notification_channel_with_http_info(
    self,
    channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[NotificationChannel]:
    """Retrieve a notification channel


    :param channel_id: The ID of the notification channel to retrieve (required)
    :type channel_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_channel_serialize(
        channel_id=channel_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationChannel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a notification channel

:param channel_id: The ID of the notification channel to retrieve (required) :type channel_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_channel_without_preload_content(self,
channel_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification channel to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_notification_channel_without_preload_content(
    self,
    channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a notification channel


    :param channel_id: The ID of the notification channel to retrieve (required)
    :type channel_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_channel_serialize(
        channel_id=channel_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationChannel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a notification channel

:param channel_id: The ID of the notification channel to retrieve (required) :type channel_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_channels(self) ‑> NotificationChannelList

Expand source code

@validate_call
def get_notification_channels(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> NotificationChannelList:
    """Retrieve notification channels


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_channels_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationChannelList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve notification channels

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_channels_with_http_info(self) ‑> ApiResponse[NotificationChannelList]

Expand source code

@validate_call
def get_notification_channels_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[NotificationChannelList]:
    """Retrieve notification channels


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_channels_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationChannelList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve notification channels

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_channels_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_notification_channels_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve notification channels


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_channels_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationChannelList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve notification channels

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_notification_channel(self,
channel_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification channel to update')],
notification_channel: Annotated[NotificationChannel, FieldInfo(annotation=NoneType, required=True, description='The updated channel')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> NotificationChannel

Expand source code

@validate_call
def update_notification_channel(
    self,
    channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to update")],
    notification_channel: Annotated[NotificationChannel, Field(description="The updated channel")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> NotificationChannel:
    """Update a notification channel

    This will affect all subscriptions which use this address!Fields which can be updated:  - enabled  - address  - awsRegion 

    :param channel_id: The ID of the notification channel to update (required)
    :type channel_id: str
    :param notification_channel: The updated channel (required)
    :type notification_channel: NotificationChannel
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_notification_channel_serialize(
        channel_id=channel_id,
        notification_channel=notification_channel,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationChannel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update a notification channel

This will affect all subscriptions which use this address!Fields which can be updated: - enabled - address - awsRegion

:param channel_id: The ID of the notification channel to update (required) :type channel_id: str :param notification_channel: The updated channel (required) :type notification_channel: NotificationChannel :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_notification_channel_with_http_info(self,
channel_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification channel to update')],
notification_channel: Annotated[NotificationChannel, FieldInfo(annotation=NoneType, required=True, description='The updated channel')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[NotificationChannel]

Expand source code

@validate_call
def update_notification_channel_with_http_info(
    self,
    channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to update")],
    notification_channel: Annotated[NotificationChannel, Field(description="The updated channel")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[NotificationChannel]:
    """Update a notification channel

    This will affect all subscriptions which use this address!Fields which can be updated:  - enabled  - address  - awsRegion 

    :param channel_id: The ID of the notification channel to update (required)
    :type channel_id: str
    :param notification_channel: The updated channel (required)
    :type notification_channel: NotificationChannel
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_notification_channel_serialize(
        channel_id=channel_id,
        notification_channel=notification_channel,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationChannel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update a notification channel

This will affect all subscriptions which use this address!Fields which can be updated: - enabled - address - awsRegion

:param channel_id: The ID of the notification channel to update (required) :type channel_id: str :param notification_channel: The updated channel (required) :type notification_channel: NotificationChannel :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_notification_channel_without_preload_content(self,
channel_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification channel to update')],
notification_channel: Annotated[NotificationChannel, FieldInfo(annotation=NoneType, required=True, description='The updated channel')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_notification_channel_without_preload_content(
    self,
    channel_id: Annotated[StrictStr, Field(description="The ID of the notification channel to update")],
    notification_channel: Annotated[NotificationChannel, Field(description="The updated channel")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update a notification channel

    This will affect all subscriptions which use this address!Fields which can be updated:  - enabled  - address  - awsRegion 

    :param channel_id: The ID of the notification channel to update (required)
    :type channel_id: str
    :param notification_channel: The updated channel (required)
    :type notification_channel: NotificationChannel
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_notification_channel_serialize(
        channel_id=channel_id,
        notification_channel=notification_channel,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationChannel",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update a notification channel

This will affect all subscriptions which use this address!Fields which can be updated: - enabled - address - awsRegion

:param channel_id: The ID of the notification channel to update (required) :type channel_id: str :param notification_channel: The updated channel (required) :type notification_channel: NotificationChannel :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class NotificationChannelList (**data: Any)

Expand source code

class NotificationChannelList(BaseModel):
    """
    NotificationChannelList
    """ # noqa: E501
    items: List[NotificationChannel]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of NotificationChannelList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of NotificationChannelList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [NotificationChannel.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

NotificationChannelList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[NotificationChannel]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of NotificationChannelList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of NotificationChannelList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class NotificationSubscription (**data: Any)

Expand source code

class NotificationSubscription(BaseModel):
    """
    NotificationSubscription
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    event_code: Annotated[str, Field(min_length=1, strict=True, max_length=20)] = Field(description="The event code to subscribe to", alias="eventCode")
    payload_version: Optional[StrictStr] = Field(default=None, description="The version of the notification event payload in case multiple versions exist. For analysis events possible values are [V3,V4]", alias="payloadVersion")
    filter_expression: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=2000)]] = Field(default=None, description="To be used when a notification applies to specific conditions.", alias="filterExpression")
    enabled: StrictBool = Field(description="Should this subscription be enabled or not?")
    notification_channel: NotificationChannel = Field(alias="notificationChannel")
    application: Optional[ApplicationV4] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "eventCode", "payloadVersion", "filterExpression", "enabled", "notificationChannel", "application"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of NotificationSubscription from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of notification_channel
        if self.notification_channel:
            _dict['notificationChannel'] = self.notification_channel.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if payload_version (nullable) is None
        # and model_fields_set contains the field
        if self.payload_version is None and "payload_version" in self.model_fields_set:
            _dict['payloadVersion'] = None

        # set to None if filter_expression (nullable) is None
        # and model_fields_set contains the field
        if self.filter_expression is None and "filter_expression" in self.model_fields_set:
            _dict['filterExpression'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of NotificationSubscription from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "eventCode": obj.get("eventCode"),
            "payloadVersion": obj.get("payloadVersion"),
            "filterExpression": obj.get("filterExpression"),
            "enabled": obj.get("enabled"),
            "notificationChannel": NotificationChannel.from_dict(obj["notificationChannel"]) if obj.get("notificationChannel") is not None else None,
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None
        })
        return _obj

NotificationSubscription

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var application : ApplicationV4 | None

The type of the None singleton.

var enabled : bool

The type of the None singleton.

var event_code : str

The type of the None singleton.

var filter_expression : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var notification_channel : NotificationChannel

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var payload_version : str | None

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of NotificationSubscription from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of NotificationSubscription from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of notification_channel
    if self.notification_channel:
        _dict['notificationChannel'] = self.notification_channel.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if payload_version (nullable) is None
    # and model_fields_set contains the field
    if self.payload_version is None and "payload_version" in self.model_fields_set:
        _dict['payloadVersion'] = None

    # set to None if filter_expression (nullable) is None
    # and model_fields_set contains the field
    if self.filter_expression is None and "filter_expression" in self.model_fields_set:
        _dict['filterExpression'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class NotificationSubscriptionList (**data: Any)

Expand source code

class NotificationSubscriptionList(BaseModel):
    """
    NotificationSubscriptionList
    """ # noqa: E501
    items: List[NotificationSubscription]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of NotificationSubscriptionList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of NotificationSubscriptionList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [NotificationSubscription.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

NotificationSubscriptionList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[NotificationSubscription]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of NotificationSubscriptionList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of NotificationSubscriptionList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class OpenApiException (*args, **kwargs)

Expand source code

class OpenApiException(Exception):
    """The base exception class for all OpenAPIExceptions"""

The base exception class for all OpenAPIExceptions

Ancestors

• builtins.Exception
• builtins.BaseException

Subclasses

• ApiAttributeError
• ApiException
• ApiKeyError
• ApiTypeError
• ApiValueError

class OptionSettings (**data: Any)

Expand source code

class OptionSettings(BaseModel):
    """
    OptionSettings
    """ # noqa: E501
    options: Optional[List[StrictStr]] = None
    default_values: Optional[List[StrictStr]] = Field(default=None, alias="defaultValues")
    __properties: ClassVar[List[str]] = ["options", "defaultValues"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of OptionSettings from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of OptionSettings from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "options": obj.get("options"),
            "defaultValues": obj.get("defaultValues")
        })
        return _obj

OptionSettings

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var default_values : List[str] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var options : List[str] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of OptionSettings from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of OptionSettings from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class OptionalSampleTags (**data: Any)

Expand source code

class OptionalSampleTags(BaseModel):
    """
    OptionalSampleTags
    """ # noqa: E501
    technical_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="technicalTags")
    user_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="userTags")
    connector_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="connectorTags")
    run_in_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, alias="runInTags")
    __properties: ClassVar[List[str]] = ["technicalTags", "userTags", "connectorTags", "runInTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of OptionalSampleTags from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if technical_tags (nullable) is None
        # and model_fields_set contains the field
        if self.technical_tags is None and "technical_tags" in self.model_fields_set:
            _dict['technicalTags'] = None

        # set to None if user_tags (nullable) is None
        # and model_fields_set contains the field
        if self.user_tags is None and "user_tags" in self.model_fields_set:
            _dict['userTags'] = None

        # set to None if connector_tags (nullable) is None
        # and model_fields_set contains the field
        if self.connector_tags is None and "connector_tags" in self.model_fields_set:
            _dict['connectorTags'] = None

        # set to None if run_in_tags (nullable) is None
        # and model_fields_set contains the field
        if self.run_in_tags is None and "run_in_tags" in self.model_fields_set:
            _dict['runInTags'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of OptionalSampleTags from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "technicalTags": obj.get("technicalTags"),
            "userTags": obj.get("userTags"),
            "connectorTags": obj.get("connectorTags"),
            "runInTags": obj.get("runInTags")
        })
        return _obj

OptionalSampleTags

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var connector_tags : List[str | None] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var run_in_tags : List[str | None] | None

The type of the None singleton.

var technical_tags : List[str | None] | None

The type of the None singleton.

var user_tags : List[str | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of OptionalSampleTags from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of OptionalSampleTags from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if technical_tags (nullable) is None
    # and model_fields_set contains the field
    if self.technical_tags is None and "technical_tags" in self.model_fields_set:
        _dict['technicalTags'] = None

    # set to None if user_tags (nullable) is None
    # and model_fields_set contains the field
    if self.user_tags is None and "user_tags" in self.model_fields_set:
        _dict['userTags'] = None

    # set to None if connector_tags (nullable) is None
    # and model_fields_set contains the field
    if self.connector_tags is None and "connector_tags" in self.model_fields_set:
        _dict['connectorTags'] = None

    # set to None if run_in_tags (nullable) is None
    # and model_fields_set contains the field
    if self.run_in_tags is None and "run_in_tags" in self.model_fields_set:
        _dict['runInTags'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineApi (api_client=None)

Expand source code

class PipelineApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def download_pipeline_file_content(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> bytearray:
        """Download the contents of a pipeline file.


        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_pipeline_file_content_serialize(
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def download_pipeline_file_content_with_http_info(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[bytearray]:
        """Download the contents of a pipeline file.


        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_pipeline_file_content_serialize(
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def download_pipeline_file_content_without_preload_content(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Download the contents of a pipeline file.


        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_pipeline_file_content_serialize(
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _download_pipeline_file_content_serialize(
        self,
        pipeline_id,
        file_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        if file_id is not None:
            _path_params['fileId'] = file_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/octet-stream'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/pipelines/{pipelineId}/files/{fileId}/content',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_pipeline(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineV4:
        """Retrieve a pipeline.


        :param pipeline_id: The ID of the pipeline to retrieve (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_pipeline_with_http_info(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineV4]:
        """Retrieve a pipeline.


        :param pipeline_id: The ID of the pipeline to retrieve (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_pipeline_without_preload_content(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a pipeline.


        :param pipeline_id: The ID of the pipeline to retrieve (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_pipeline_serialize(
        self,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/pipelines/{pipelineId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_pipeline_configuration_parameters(
        self,
        pipeline_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineConfigurationParameterList:
        """Retrieve configuration parameters for a pipeline.


        :param pipeline_id: (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_configuration_parameters_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineConfigurationParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_pipeline_configuration_parameters_with_http_info(
        self,
        pipeline_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineConfigurationParameterList]:
        """Retrieve configuration parameters for a pipeline.


        :param pipeline_id: (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_configuration_parameters_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineConfigurationParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_pipeline_configuration_parameters_without_preload_content(
        self,
        pipeline_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve configuration parameters for a pipeline.


        :param pipeline_id: (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_configuration_parameters_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineConfigurationParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_pipeline_configuration_parameters_serialize(
        self,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/pipelines/{pipelineId}/configurationParameters',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_pipeline_files(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineFileList:
        """Retrieve files for a pipeline.


        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_files_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineFileList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_pipeline_files_with_http_info(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineFileList]:
        """Retrieve files for a pipeline.


        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_files_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineFileList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_pipeline_files_without_preload_content(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve files for a pipeline.


        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_files_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineFileList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_pipeline_files_serialize(
        self,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/pipelines/{pipelineId}/files',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_pipeline_html_documentation(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineHtmlDocumentation:
        """Retrieve HTML documentation for a project pipeline.

        Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

        :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_html_documentation_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineHtmlDocumentation",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_pipeline_html_documentation_with_http_info(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineHtmlDocumentation]:
        """Retrieve HTML documentation for a project pipeline.

        Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

        :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_html_documentation_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineHtmlDocumentation",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_pipeline_html_documentation_without_preload_content(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve HTML documentation for a project pipeline.

        Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

        :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_html_documentation_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineHtmlDocumentation",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_pipeline_html_documentation_serialize(
        self,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/pipelines/{pipelineId}/documentation/HTML',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_pipeline_input_parameters(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve input parameters for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> InputParameterList:
        """Retrieve input parameters for a pipeline.


        :param pipeline_id: The ID of the pipeline to retrieve input parameters for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_input_parameters_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InputParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_pipeline_input_parameters_with_http_info(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve input parameters for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[InputParameterList]:
        """Retrieve input parameters for a pipeline.


        :param pipeline_id: The ID of the pipeline to retrieve input parameters for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_input_parameters_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InputParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_pipeline_input_parameters_without_preload_content(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve input parameters for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve input parameters for a pipeline.


        :param pipeline_id: The ID of the pipeline to retrieve input parameters for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_input_parameters_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InputParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_pipeline_input_parameters_serialize(
        self,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/pipelines/{pipelineId}/inputParameters',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_pipeline_reference_sets(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ReferenceSetList:
        """Retrieve the reference sets of a pipeline.


        :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_reference_sets_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ReferenceSetList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_pipeline_reference_sets_with_http_info(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ReferenceSetList]:
        """Retrieve the reference sets of a pipeline.


        :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_reference_sets_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ReferenceSetList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_pipeline_reference_sets_without_preload_content(
        self,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the reference sets of a pipeline.


        :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipeline_reference_sets_serialize(
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ReferenceSetList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_pipeline_reference_sets_serialize(
        self,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/pipelines/{pipelineId}/referenceSets',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_pipelines(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineList:
        """Retrieve a list of pipelines.

        Only lists pipelines that are owned by the user/tenant (not those to which a user is entitled).

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipelines_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_pipelines_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineList]:
        """Retrieve a list of pipelines.

        Only lists pipelines that are owned by the user/tenant (not those to which a user is entitled).

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipelines_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_pipelines_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of pipelines.

        Only lists pipelines that are owned by the user/tenant (not those to which a user is entitled).

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_pipelines_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_pipelines_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/pipelines',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def download_pipeline_file_content(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> bytearray

Expand source code

@validate_call
def download_pipeline_file_content(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> bytearray:
    """Download the contents of a pipeline file.


    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_pipeline_file_content_serialize(
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Download the contents of a pipeline file.

:param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_pipeline_file_content_with_http_info(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> ApiResponse[bytearray]

Expand source code

@validate_call
def download_pipeline_file_content_with_http_info(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[bytearray]:
    """Download the contents of a pipeline file.


    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_pipeline_file_content_serialize(
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Download the contents of a pipeline file.

:param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_pipeline_file_content_without_preload_content(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def download_pipeline_file_content_without_preload_content(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Download the contents of a pipeline file.


    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_pipeline_file_content_serialize(
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Download the contents of a pipeline file.

:param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve')]) ‑> PipelineV4

Expand source code

@validate_call
def get_pipeline(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineV4:
    """Retrieve a pipeline.


    :param pipeline_id: The ID of the pipeline to retrieve (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a pipeline.

:param pipeline_id: The ID of the pipeline to retrieve (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_configuration_parameters(self, pipeline_id: Annotated[str, Strict(strict=True)]) ‑> PipelineConfigurationParameterList

Expand source code

@validate_call
def get_pipeline_configuration_parameters(
    self,
    pipeline_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineConfigurationParameterList:
    """Retrieve configuration parameters for a pipeline.


    :param pipeline_id: (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_configuration_parameters_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineConfigurationParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve configuration parameters for a pipeline.

:param pipeline_id: (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_configuration_parameters_with_http_info(self, pipeline_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[PipelineConfigurationParameterList]

Expand source code

@validate_call
def get_pipeline_configuration_parameters_with_http_info(
    self,
    pipeline_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineConfigurationParameterList]:
    """Retrieve configuration parameters for a pipeline.


    :param pipeline_id: (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_configuration_parameters_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineConfigurationParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve configuration parameters for a pipeline.

:param pipeline_id: (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_configuration_parameters_without_preload_content(self, pipeline_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_pipeline_configuration_parameters_without_preload_content(
    self,
    pipeline_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve configuration parameters for a pipeline.


    :param pipeline_id: (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_configuration_parameters_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineConfigurationParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve configuration parameters for a pipeline.

:param pipeline_id: (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_files(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')]) ‑> PipelineFileList

Expand source code

@validate_call
def get_pipeline_files(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineFileList:
    """Retrieve files for a pipeline.


    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_files_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineFileList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve files for a pipeline.

:param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_files_with_http_info(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')]) ‑> ApiResponse[PipelineFileList]

Expand source code

@validate_call
def get_pipeline_files_with_http_info(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineFileList]:
    """Retrieve files for a pipeline.


    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_files_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineFileList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve files for a pipeline.

:param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_files_without_preload_content(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_pipeline_files_without_preload_content(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve files for a pipeline.


    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_files_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineFileList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve files for a pipeline.

:param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_html_documentation(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve HTML documentation from')]) ‑> PipelineHtmlDocumentation

Expand source code

@validate_call
def get_pipeline_html_documentation(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineHtmlDocumentation:
    """Retrieve HTML documentation for a project pipeline.

    Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

    :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_html_documentation_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineHtmlDocumentation",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve HTML documentation for a project pipeline.

Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

:param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_html_documentation_with_http_info(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve HTML documentation from')]) ‑> ApiResponse[PipelineHtmlDocumentation]

Expand source code

@validate_call
def get_pipeline_html_documentation_with_http_info(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineHtmlDocumentation]:
    """Retrieve HTML documentation for a project pipeline.

    Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

    :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_html_documentation_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineHtmlDocumentation",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve HTML documentation for a project pipeline.

Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

:param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_html_documentation_without_preload_content(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve HTML documentation from')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_pipeline_html_documentation_without_preload_content(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve HTML documentation for a project pipeline.

    Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

    :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_html_documentation_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineHtmlDocumentation",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve HTML documentation for a project pipeline.

Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

:param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_input_parameters(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve input parameters for')]) ‑> InputParameterList

Expand source code

@validate_call
def get_pipeline_input_parameters(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve input parameters for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> InputParameterList:
    """Retrieve input parameters for a pipeline.


    :param pipeline_id: The ID of the pipeline to retrieve input parameters for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_input_parameters_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InputParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve input parameters for a pipeline.

:param pipeline_id: The ID of the pipeline to retrieve input parameters for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_input_parameters_with_http_info(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve input parameters for')]) ‑> ApiResponse[InputParameterList]

Expand source code

@validate_call
def get_pipeline_input_parameters_with_http_info(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve input parameters for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[InputParameterList]:
    """Retrieve input parameters for a pipeline.


    :param pipeline_id: The ID of the pipeline to retrieve input parameters for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_input_parameters_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InputParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve input parameters for a pipeline.

:param pipeline_id: The ID of the pipeline to retrieve input parameters for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_input_parameters_without_preload_content(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve input parameters for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_pipeline_input_parameters_without_preload_content(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve input parameters for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve input parameters for a pipeline.


    :param pipeline_id: The ID of the pipeline to retrieve input parameters for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_input_parameters_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InputParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve input parameters for a pipeline.

:param pipeline_id: The ID of the pipeline to retrieve input parameters for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_reference_sets(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve reference sets for')]) ‑> ReferenceSetList

Expand source code

@validate_call
def get_pipeline_reference_sets(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ReferenceSetList:
    """Retrieve the reference sets of a pipeline.


    :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_reference_sets_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ReferenceSetList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the reference sets of a pipeline.

:param pipeline_id: The ID of the pipeline to retrieve reference sets for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_reference_sets_with_http_info(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve reference sets for')]) ‑> ApiResponse[ReferenceSetList]

Expand source code

@validate_call
def get_pipeline_reference_sets_with_http_info(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ReferenceSetList]:
    """Retrieve the reference sets of a pipeline.


    :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_reference_sets_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ReferenceSetList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the reference sets of a pipeline.

:param pipeline_id: The ID of the pipeline to retrieve reference sets for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_reference_sets_without_preload_content(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve reference sets for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_pipeline_reference_sets_without_preload_content(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the reference sets of a pipeline.


    :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_reference_sets_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ReferenceSetList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the reference sets of a pipeline.

:param pipeline_id: The ID of the pipeline to retrieve reference sets for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_with_http_info(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve')]) ‑> ApiResponse[PipelineV4]

Expand source code

@validate_call
def get_pipeline_with_http_info(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineV4]:
    """Retrieve a pipeline.


    :param pipeline_id: The ID of the pipeline to retrieve (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a pipeline.

:param pipeline_id: The ID of the pipeline to retrieve (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipeline_without_preload_content(self,
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_pipeline_without_preload_content(
    self,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a pipeline.


    :param pipeline_id: The ID of the pipeline to retrieve (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipeline_serialize(
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a pipeline.

:param pipeline_id: The ID of the pipeline to retrieve (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipelines(self) ‑> PipelineList

Expand source code

@validate_call
def get_pipelines(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineList:
    """Retrieve a list of pipelines.

    Only lists pipelines that are owned by the user/tenant (not those to which a user is entitled).

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipelines_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of pipelines.

Only lists pipelines that are owned by the user/tenant (not those to which a user is entitled).

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipelines_with_http_info(self) ‑> ApiResponse[PipelineList]

Expand source code

@validate_call
def get_pipelines_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineList]:
    """Retrieve a list of pipelines.

    Only lists pipelines that are owned by the user/tenant (not those to which a user is entitled).

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipelines_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of pipelines.

Only lists pipelines that are owned by the user/tenant (not those to which a user is entitled).

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_pipelines_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_pipelines_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of pipelines.

    Only lists pipelines that are owned by the user/tenant (not those to which a user is entitled).

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_pipelines_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of pipelines.

Only lists pipelines that are owned by the user/tenant (not those to which a user is entitled).

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class PipelineBundle (**data: Any)

Expand source code

class PipelineBundle(BaseModel):
    """
    PipelineBundle
    """ # noqa: E501
    id: StrictStr
    name: StrictStr
    max_number_of_allowed_slots: Annotated[int, Field(strict=True, ge=-1)] = Field(alias="maxNumberOfAllowedSlots")
    active_pipelines: List[PipelineV3] = Field(alias="activePipelines")
    canceled_pipelines: List[PipelineV3] = Field(alias="canceledPipelines")
    retired_pipelines: List[PipelineV3] = Field(alias="retiredPipelines")
    regions: List[Region]
    analysis_storages: List[AnalysisStorageV3] = Field(alias="analysisStorages")
    __properties: ClassVar[List[str]] = ["id", "name", "maxNumberOfAllowedSlots", "activePipelines", "canceledPipelines", "retiredPipelines", "regions", "analysisStorages"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineBundle from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in active_pipelines (list)
        _items = []
        if self.active_pipelines:
            for _item_active_pipelines in self.active_pipelines:
                if _item_active_pipelines:
                    _items.append(_item_active_pipelines.to_dict())
            _dict['activePipelines'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in canceled_pipelines (list)
        _items = []
        if self.canceled_pipelines:
            for _item_canceled_pipelines in self.canceled_pipelines:
                if _item_canceled_pipelines:
                    _items.append(_item_canceled_pipelines.to_dict())
            _dict['canceledPipelines'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in retired_pipelines (list)
        _items = []
        if self.retired_pipelines:
            for _item_retired_pipelines in self.retired_pipelines:
                if _item_retired_pipelines:
                    _items.append(_item_retired_pipelines.to_dict())
            _dict['retiredPipelines'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in regions (list)
        _items = []
        if self.regions:
            for _item_regions in self.regions:
                if _item_regions:
                    _items.append(_item_regions.to_dict())
            _dict['regions'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_storages (list)
        _items = []
        if self.analysis_storages:
            for _item_analysis_storages in self.analysis_storages:
                if _item_analysis_storages:
                    _items.append(_item_analysis_storages.to_dict())
            _dict['analysisStorages'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineBundle from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name"),
            "maxNumberOfAllowedSlots": obj.get("maxNumberOfAllowedSlots"),
            "activePipelines": [PipelineV3.from_dict(_item) for _item in obj["activePipelines"]] if obj.get("activePipelines") is not None else None,
            "canceledPipelines": [PipelineV3.from_dict(_item) for _item in obj["canceledPipelines"]] if obj.get("canceledPipelines") is not None else None,
            "retiredPipelines": [PipelineV3.from_dict(_item) for _item in obj["retiredPipelines"]] if obj.get("retiredPipelines") is not None else None,
            "regions": [Region.from_dict(_item) for _item in obj["regions"]] if obj.get("regions") is not None else None,
            "analysisStorages": [AnalysisStorageV3.from_dict(_item) for _item in obj["analysisStorages"]] if obj.get("analysisStorages") is not None else None
        })
        return _obj

PipelineBundle

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var active_pipelines : List[PipelineV3]

The type of the None singleton.

var analysis_storages : List[AnalysisStorageV3]

The type of the None singleton.

var canceled_pipelines : List[PipelineV3]

The type of the None singleton.

var id : str

The type of the None singleton.

var max_number_of_allowed_slots : int

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var regions : List[Region]

The type of the None singleton.

var retired_pipelines : List[PipelineV3]

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineBundle from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineBundle from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in active_pipelines (list)
    _items = []
    if self.active_pipelines:
        for _item_active_pipelines in self.active_pipelines:
            if _item_active_pipelines:
                _items.append(_item_active_pipelines.to_dict())
        _dict['activePipelines'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in canceled_pipelines (list)
    _items = []
    if self.canceled_pipelines:
        for _item_canceled_pipelines in self.canceled_pipelines:
            if _item_canceled_pipelines:
                _items.append(_item_canceled_pipelines.to_dict())
        _dict['canceledPipelines'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in retired_pipelines (list)
    _items = []
    if self.retired_pipelines:
        for _item_retired_pipelines in self.retired_pipelines:
            if _item_retired_pipelines:
                _items.append(_item_retired_pipelines.to_dict())
        _dict['retiredPipelines'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in regions (list)
    _items = []
    if self.regions:
        for _item_regions in self.regions:
            if _item_regions:
                _items.append(_item_regions.to_dict())
        _dict['regions'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_storages (list)
    _items = []
    if self.analysis_storages:
        for _item_analysis_storages in self.analysis_storages:
            if _item_analysis_storages:
                _items.append(_item_analysis_storages.to_dict())
        _dict['analysisStorages'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineConfigurationParameter (**data: Any)

Expand source code

class PipelineConfigurationParameter(BaseModel):
    """
    PipelineConfigurationParameter
    """ # noqa: E501
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The code of the parameter")
    required: StrictBool = Field(description="Indicates whether this parameter is required")
    multi_value: StrictBool = Field(description="Indicates whether multiple values are allowed for this parameter", alias="multiValue")
    type: StrictStr = Field(description="The type for each parameter")
    settings: Optional[Settings] = None
    __properties: ClassVar[List[str]] = ["code", "required", "multiValue", "type", "settings"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineConfigurationParameter from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of settings
        if self.settings:
            _dict['settings'] = self.settings.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineConfigurationParameter from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "required": obj.get("required"),
            "multiValue": obj.get("multiValue"),
            "type": obj.get("type"),
            "settings": Settings.from_dict(obj["settings"]) if obj.get("settings") is not None else None
        })
        return _obj

PipelineConfigurationParameter

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str

The type of the None singleton.

var model_config

The type of the None singleton.

var multi_value : bool

The type of the None singleton.

var required : bool

The type of the None singleton.

var settings : Settings | None

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineConfigurationParameter from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineConfigurationParameter from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of settings
    if self.settings:
        _dict['settings'] = self.settings.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineConfigurationParameterList (**data: Any)

Expand source code

class PipelineConfigurationParameterList(BaseModel):
    """
    PipelineConfigurationParameterList
    """ # noqa: E501
    items: List[PipelineConfigurationParameter]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineConfigurationParameterList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineConfigurationParameterList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [PipelineConfigurationParameter.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

PipelineConfigurationParameterList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[PipelineConfigurationParameter]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineConfigurationParameterList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineConfigurationParameterList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineFile (**data: Any)

Expand source code

class PipelineFile(BaseModel):
    """
    PipelineFile
    """ # noqa: E501
    id: StrictStr
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    __properties: ClassVar[List[str]] = ["id", "name"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineFile from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineFile from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name")
        })
        return _obj

PipelineFile

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineFile from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineFile from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineFileList (**data: Any)

Expand source code

class PipelineFileList(BaseModel):
    """
    PipelineFileList
    """ # noqa: E501
    items: List[PipelineFile]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineFileList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineFileList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [PipelineFile.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

PipelineFileList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[PipelineFile]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineFileList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineFileList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineHtmlDocumentation (**data: Any)

Expand source code

class PipelineHtmlDocumentation(BaseModel):
    """
    PipelineHtmlDocumentation
    """ # noqa: E501
    content: StrictStr = Field(description="The content of the HTML documentation")
    __properties: ClassVar[List[str]] = ["content"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineHtmlDocumentation from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineHtmlDocumentation from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "content": obj.get("content")
        })
        return _obj

PipelineHtmlDocumentation

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var content : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineHtmlDocumentation from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineHtmlDocumentation from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineLanguageApi (api_client=None)

Expand source code

class PipelineLanguageApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_nextflow_versions(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineLanguageVersionList:
        """Retrieve a list of nextflow versions.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_nextflow_versions_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineLanguageVersionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_nextflow_versions_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineLanguageVersionList]:
        """Retrieve a list of nextflow versions.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_nextflow_versions_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineLanguageVersionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_nextflow_versions_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of nextflow versions.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_nextflow_versions_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineLanguageVersionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_nextflow_versions_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/pipelineLanguages/nextflow/versions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_nextflow_versions(self) ‑> PipelineLanguageVersionList

Expand source code

@validate_call
def get_nextflow_versions(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineLanguageVersionList:
    """Retrieve a list of nextflow versions.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_nextflow_versions_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineLanguageVersionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of nextflow versions.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_nextflow_versions_with_http_info(self) ‑> ApiResponse[PipelineLanguageVersionList]

Expand source code

@validate_call
def get_nextflow_versions_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineLanguageVersionList]:
    """Retrieve a list of nextflow versions.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_nextflow_versions_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineLanguageVersionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of nextflow versions.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_nextflow_versions_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_nextflow_versions_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of nextflow versions.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_nextflow_versions_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineLanguageVersionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of nextflow versions.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class PipelineLanguageVersion (**data: Any)

Expand source code

class PipelineLanguageVersion(BaseModel):
    """
    PipelineLanguageVersion
    """ # noqa: E501
    id: StrictStr
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the version")
    language: StrictStr = Field(description="The language of the version")
    __properties: ClassVar[List[str]] = ["id", "name", "language"]

    @field_validator('language')
    def language_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['CWL', 'NEXTFLOW', 'UNKNOWN']):
            raise ValueError("must be one of enum values ('CWL', 'NEXTFLOW', 'UNKNOWN')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineLanguageVersion from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineLanguageVersion from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name"),
            "language": obj.get("language")
        })
        return _obj

PipelineLanguageVersion

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var language : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineLanguageVersion from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineLanguageVersion from a JSON string

def language_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineLanguageVersionList (**data: Any)

Expand source code

class PipelineLanguageVersionList(BaseModel):
    """
    PipelineLanguageVersionList
    """ # noqa: E501
    items: List[Optional[PipelineLanguageVersion]]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineLanguageVersionList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineLanguageVersionList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [PipelineLanguageVersion.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

PipelineLanguageVersionList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[PipelineLanguageVersion | None]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineLanguageVersionList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineLanguageVersionList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineList (**data: Any)

Expand source code

class PipelineList(BaseModel):
    """
    PipelineList
    """ # noqa: E501
    items: List[PipelineV3]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [PipelineV3.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

PipelineList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[PipelineV3]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineReportConfig (**data: Any)

Expand source code

class PipelineReportConfig(BaseModel):
    """
    PipelineReportConfig
    """ # noqa: E501
    configs: Optional[List[Config]] = None
    __properties: ClassVar[List[str]] = ["configs"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineReportConfig from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in configs (list)
        _items = []
        if self.configs:
            for _item_configs in self.configs:
                if _item_configs:
                    _items.append(_item_configs.to_dict())
            _dict['configs'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineReportConfig from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "configs": [Config.from_dict(_item) for _item in obj["configs"]] if obj.get("configs") is not None else None
        })
        return _obj

PipelineReportConfig

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var configs : List[Config] | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineReportConfig from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineReportConfig from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in configs (list)
    _items = []
    if self.configs:
        for _item_configs in self.configs:
            if _item_configs:
                _items.append(_item_configs.to_dict())
        _dict['configs'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineResources (**data: Any)

Expand source code

class PipelineResources(BaseModel):
    """
    PipelineResources
    """ # noqa: E501
    f1: Optional[StrictBool] = None
    f2: Optional[StrictBool] = None
    gpu: Optional[StrictBool] = None
    software_only: Optional[StrictBool] = Field(default=None, description="Can not be true in case one of [f1,f2,gpu] is also true.", alias="software-only")
    __properties: ClassVar[List[str]] = ["f1", "f2", "gpu", "software-only"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineResources from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if f1 (nullable) is None
        # and model_fields_set contains the field
        if self.f1 is None and "f1" in self.model_fields_set:
            _dict['f1'] = None

        # set to None if f2 (nullable) is None
        # and model_fields_set contains the field
        if self.f2 is None and "f2" in self.model_fields_set:
            _dict['f2'] = None

        # set to None if gpu (nullable) is None
        # and model_fields_set contains the field
        if self.gpu is None and "gpu" in self.model_fields_set:
            _dict['gpu'] = None

        # set to None if software_only (nullable) is None
        # and model_fields_set contains the field
        if self.software_only is None and "software_only" in self.model_fields_set:
            _dict['software-only'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineResources from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "f1": obj.get("f1"),
            "f2": obj.get("f2"),
            "gpu": obj.get("gpu"),
            "software-only": obj.get("software-only")
        })
        return _obj

PipelineResources

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var f1 : bool | None

The type of the None singleton.

var f2 : bool | None

The type of the None singleton.

var gpu : bool | None

The type of the None singleton.

var model_config

The type of the None singleton.

var software_only : bool | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineResources from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineResources from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if f1 (nullable) is None
    # and model_fields_set contains the field
    if self.f1 is None and "f1" in self.model_fields_set:
        _dict['f1'] = None

    # set to None if f2 (nullable) is None
    # and model_fields_set contains the field
    if self.f2 is None and "f2" in self.model_fields_set:
        _dict['f2'] = None

    # set to None if gpu (nullable) is None
    # and model_fields_set contains the field
    if self.gpu is None and "gpu" in self.model_fields_set:
        _dict['gpu'] = None

    # set to None if software_only (nullable) is None
    # and model_fields_set contains the field
    if self.software_only is None and "software_only" in self.model_fields_set:
        _dict['software-only'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineTag (**data: Any)

Expand source code

class PipelineTag(BaseModel):
    """
    PipelineTag
    """ # noqa: E501
    technical_tags: List[StrictStr] = Field(description="Technical tags", alias="technicalTags")
    __properties: ClassVar[List[str]] = ["technicalTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineTag from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineTag from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "technicalTags": obj.get("technicalTags")
        })
        return _obj

PipelineTag

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var technical_tags : List[str]

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineTag from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineTag from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineUpdate (**data: Any)

Expand source code

class PipelineUpdate(BaseModel):
    """
    PipelineUpdate
    """ # noqa: E501
    code: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="The code of the pipeline")
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = Field(default=None, description="The description of the pipeline")
    language_version: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="Version of the pipeline language ", alias="languageVersion")
    proprietary: Optional[StrictBool] = Field(default=None, description="A boolean which indicates if the code of this pipeline is proprietary")
    resources: Optional[PipelineResources] = None
    __properties: ClassVar[List[str]] = ["code", "description", "languageVersion", "proprietary", "resources"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineUpdate from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of resources
        if self.resources:
            _dict['resources'] = self.resources.to_dict()
        # set to None if code (nullable) is None
        # and model_fields_set contains the field
        if self.code is None and "code" in self.model_fields_set:
            _dict['code'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if language_version (nullable) is None
        # and model_fields_set contains the field
        if self.language_version is None and "language_version" in self.model_fields_set:
            _dict['languageVersion'] = None

        # set to None if proprietary (nullable) is None
        # and model_fields_set contains the field
        if self.proprietary is None and "proprietary" in self.model_fields_set:
            _dict['proprietary'] = None

        # set to None if resources (nullable) is None
        # and model_fields_set contains the field
        if self.resources is None and "resources" in self.model_fields_set:
            _dict['resources'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineUpdate from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "description": obj.get("description"),
            "languageVersion": obj.get("languageVersion"),
            "proprietary": obj.get("proprietary"),
            "resources": PipelineResources.from_dict(obj["resources"]) if obj.get("resources") is not None else None
        })
        return _obj

PipelineUpdate

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str | None

The type of the None singleton.

var description : str | None

The type of the None singleton.

var language_version : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var proprietary : bool | None

The type of the None singleton.

var resources : PipelineResources | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineUpdate from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineUpdate from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of resources
    if self.resources:
        _dict['resources'] = self.resources.to_dict()
    # set to None if code (nullable) is None
    # and model_fields_set contains the field
    if self.code is None and "code" in self.model_fields_set:
        _dict['code'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if language_version (nullable) is None
    # and model_fields_set contains the field
    if self.language_version is None and "language_version" in self.model_fields_set:
        _dict['languageVersion'] = None

    # set to None if proprietary (nullable) is None
    # and model_fields_set contains the field
    if self.proprietary is None and "proprietary" in self.model_fields_set:
        _dict['proprietary'] = None

    # set to None if resources (nullable) is None
    # and model_fields_set contains the field
    if self.resources is None and "resources" in self.model_fields_set:
        _dict['resources'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineV3 (**data: Any)

Expand source code

class PipelineV3(BaseModel):
    """
    PipelineV3
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The code of the pipeline")
    urn: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=2000)]] = Field(default=None, description="The URN of the pipeline. The format is urn:ilmn:ica:\\<type of the object\\>:\\<ID of the object\\>#\\<optional human readable hint representing the object\\>. The hint can be omitted, in that case the hashtag (#) must also be omitted.")
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000)] = Field(description="The description of the pipeline")
    status: Optional[StrictStr] = Field(default=None, description="The status of the pipeline")
    language: StrictStr = Field(description="The language that is used by the pipeline")
    language_version: Optional[PipelineLanguageVersion] = Field(default=None, alias="languageVersion")
    pipeline_tags: PipelineTag = Field(alias="pipelineTags")
    analysis_storage: AnalysisStorageV3 = Field(alias="analysisStorage")
    proprietary: Optional[StrictBool] = Field(default=False, description="A boolean which indicates if the code of this pipeline is proprietary")
    input_form_type: Optional[StrictStr] = Field(default=None, description="The type of the inputform used.", alias="inputFormType")
    resources: Optional[PipelineResources] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "code", "urn", "description", "status", "language", "languageVersion", "pipelineTags", "analysisStorage", "proprietary", "inputFormType", "resources"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['DRAFT', 'RELEASED']):
            raise ValueError("must be one of enum values ('DRAFT', 'RELEASED')")
        return value

    @field_validator('language')
    def language_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['CWL', 'NEXTFLOW', 'UNKNOWN']):
            raise ValueError("must be one of enum values ('CWL', 'NEXTFLOW', 'UNKNOWN')")
        return value

    @field_validator('input_form_type')
    def input_form_type_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['XML', 'JSON']):
            raise ValueError("must be one of enum values ('XML', 'JSON')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of language_version
        if self.language_version:
            _dict['languageVersion'] = self.language_version.to_dict()
        # override the default output from pydantic by calling `to_dict()` of pipeline_tags
        if self.pipeline_tags:
            _dict['pipelineTags'] = self.pipeline_tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of analysis_storage
        if self.analysis_storage:
            _dict['analysisStorage'] = self.analysis_storage.to_dict()
        # override the default output from pydantic by calling `to_dict()` of resources
        if self.resources:
            _dict['resources'] = self.resources.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if urn (nullable) is None
        # and model_fields_set contains the field
        if self.urn is None and "urn" in self.model_fields_set:
            _dict['urn'] = None

        # set to None if status (nullable) is None
        # and model_fields_set contains the field
        if self.status is None and "status" in self.model_fields_set:
            _dict['status'] = None

        # set to None if language_version (nullable) is None
        # and model_fields_set contains the field
        if self.language_version is None and "language_version" in self.model_fields_set:
            _dict['languageVersion'] = None

        # set to None if proprietary (nullable) is None
        # and model_fields_set contains the field
        if self.proprietary is None and "proprietary" in self.model_fields_set:
            _dict['proprietary'] = None

        # set to None if resources (nullable) is None
        # and model_fields_set contains the field
        if self.resources is None and "resources" in self.model_fields_set:
            _dict['resources'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "code": obj.get("code"),
            "urn": obj.get("urn"),
            "description": obj.get("description"),
            "status": obj.get("status"),
            "language": obj.get("language"),
            "languageVersion": PipelineLanguageVersion.from_dict(obj["languageVersion"]) if obj.get("languageVersion") is not None else None,
            "pipelineTags": PipelineTag.from_dict(obj["pipelineTags"]) if obj.get("pipelineTags") is not None else None,
            "analysisStorage": AnalysisStorageV3.from_dict(obj["analysisStorage"]) if obj.get("analysisStorage") is not None else None,
            "proprietary": obj.get("proprietary") if obj.get("proprietary") is not None else False,
            "inputFormType": obj.get("inputFormType"),
            "resources": PipelineResources.from_dict(obj["resources"]) if obj.get("resources") is not None else None
        })
        return _obj

PipelineV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_storage : AnalysisStorageV3

The type of the None singleton.

var code : str

The type of the None singleton.

var description : str

The type of the None singleton.

var id : str

The type of the None singleton.

var input_form_type : str | None

The type of the None singleton.

var language : str

The type of the None singleton.

var language_version : PipelineLanguageVersion | None

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var pipeline_tags : PipelineTag

The type of the None singleton.

var proprietary : bool | None

The type of the None singleton.

var resources : PipelineResources | None

The type of the None singleton.

var status : str | None

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var urn : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineV3 from a JSON string

def input_form_type_validate_enum(value)

Validates the enum

def language_validate_enum(value)

Validates the enum

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of language_version
    if self.language_version:
        _dict['languageVersion'] = self.language_version.to_dict()
    # override the default output from pydantic by calling `to_dict()` of pipeline_tags
    if self.pipeline_tags:
        _dict['pipelineTags'] = self.pipeline_tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of analysis_storage
    if self.analysis_storage:
        _dict['analysisStorage'] = self.analysis_storage.to_dict()
    # override the default output from pydantic by calling `to_dict()` of resources
    if self.resources:
        _dict['resources'] = self.resources.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if urn (nullable) is None
    # and model_fields_set contains the field
    if self.urn is None and "urn" in self.model_fields_set:
        _dict['urn'] = None

    # set to None if status (nullable) is None
    # and model_fields_set contains the field
    if self.status is None and "status" in self.model_fields_set:
        _dict['status'] = None

    # set to None if language_version (nullable) is None
    # and model_fields_set contains the field
    if self.language_version is None and "language_version" in self.model_fields_set:
        _dict['languageVersion'] = None

    # set to None if proprietary (nullable) is None
    # and model_fields_set contains the field
    if self.proprietary is None and "proprietary" in self.model_fields_set:
        _dict['proprietary'] = None

    # set to None if resources (nullable) is None
    # and model_fields_set contains the field
    if self.resources is None and "resources" in self.model_fields_set:
        _dict['resources'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class PipelineV4 (**data: Any)

Expand source code

class PipelineV4(BaseModel):
    """
    PipelineV4
    """ # noqa: E501
    id: StrictStr
    urn: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=2000)]] = Field(default=None, description="The URN of the pipeline. The format is urn:ilmn:ica:\\<type of the object\\>:\\<ID of the object\\>#\\<optional human readable hint representing the object\\>. The hint can be omitted, in that case the hashtag (#) must also be omitted.")
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner: UserIdentifier
    tenant: TenantIdentifier
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The code of the pipeline")
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000)] = Field(description="The description of the pipeline")
    status: Optional[StrictStr] = Field(default=None, description="The status of the pipeline")
    language: StrictStr = Field(description="The language that is used by the pipeline")
    language_version: Optional[PipelineLanguageVersion] = Field(default=None, alias="languageVersion")
    pipeline_tags: PipelineTag = Field(alias="pipelineTags")
    analysis_storage: AnalysisStorageV4 = Field(alias="analysisStorage")
    proprietary: Optional[StrictBool] = Field(default=False, description="A boolean which indicates if the code of this pipeline is proprietary")
    input_form_type: Optional[StrictStr] = Field(default=None, description="The type of the inputform used.", alias="inputFormType")
    report_configs: Optional[PipelineReportConfig] = Field(default=None, alias="reportConfigs")
    resources: Optional[PipelineResources] = None
    __properties: ClassVar[List[str]] = ["id", "urn", "timeCreated", "timeModified", "owner", "tenant", "code", "description", "status", "language", "languageVersion", "pipelineTags", "analysisStorage", "proprietary", "inputFormType", "reportConfigs", "resources"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['DRAFT', 'RELEASED']):
            raise ValueError("must be one of enum values ('DRAFT', 'RELEASED')")
        return value

    @field_validator('language')
    def language_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['CWL', 'NEXTFLOW', 'UNKNOWN']):
            raise ValueError("must be one of enum values ('CWL', 'NEXTFLOW', 'UNKNOWN')")
        return value

    @field_validator('input_form_type')
    def input_form_type_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['XML', 'JSON']):
            raise ValueError("must be one of enum values ('XML', 'JSON')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of PipelineV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of owner
        if self.owner:
            _dict['owner'] = self.owner.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tenant
        if self.tenant:
            _dict['tenant'] = self.tenant.to_dict()
        # override the default output from pydantic by calling `to_dict()` of language_version
        if self.language_version:
            _dict['languageVersion'] = self.language_version.to_dict()
        # override the default output from pydantic by calling `to_dict()` of pipeline_tags
        if self.pipeline_tags:
            _dict['pipelineTags'] = self.pipeline_tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of analysis_storage
        if self.analysis_storage:
            _dict['analysisStorage'] = self.analysis_storage.to_dict()
        # override the default output from pydantic by calling `to_dict()` of report_configs
        if self.report_configs:
            _dict['reportConfigs'] = self.report_configs.to_dict()
        # override the default output from pydantic by calling `to_dict()` of resources
        if self.resources:
            _dict['resources'] = self.resources.to_dict()
        # set to None if urn (nullable) is None
        # and model_fields_set contains the field
        if self.urn is None and "urn" in self.model_fields_set:
            _dict['urn'] = None

        # set to None if status (nullable) is None
        # and model_fields_set contains the field
        if self.status is None and "status" in self.model_fields_set:
            _dict['status'] = None

        # set to None if language_version (nullable) is None
        # and model_fields_set contains the field
        if self.language_version is None and "language_version" in self.model_fields_set:
            _dict['languageVersion'] = None

        # set to None if proprietary (nullable) is None
        # and model_fields_set contains the field
        if self.proprietary is None and "proprietary" in self.model_fields_set:
            _dict['proprietary'] = None

        # set to None if report_configs (nullable) is None
        # and model_fields_set contains the field
        if self.report_configs is None and "report_configs" in self.model_fields_set:
            _dict['reportConfigs'] = None

        # set to None if resources (nullable) is None
        # and model_fields_set contains the field
        if self.resources is None and "resources" in self.model_fields_set:
            _dict['resources'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of PipelineV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "urn": obj.get("urn"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "owner": UserIdentifier.from_dict(obj["owner"]) if obj.get("owner") is not None else None,
            "tenant": TenantIdentifier.from_dict(obj["tenant"]) if obj.get("tenant") is not None else None,
            "code": obj.get("code"),
            "description": obj.get("description"),
            "status": obj.get("status"),
            "language": obj.get("language"),
            "languageVersion": PipelineLanguageVersion.from_dict(obj["languageVersion"]) if obj.get("languageVersion") is not None else None,
            "pipelineTags": PipelineTag.from_dict(obj["pipelineTags"]) if obj.get("pipelineTags") is not None else None,
            "analysisStorage": AnalysisStorageV4.from_dict(obj["analysisStorage"]) if obj.get("analysisStorage") is not None else None,
            "proprietary": obj.get("proprietary") if obj.get("proprietary") is not None else False,
            "inputFormType": obj.get("inputFormType"),
            "reportConfigs": PipelineReportConfig.from_dict(obj["reportConfigs"]) if obj.get("reportConfigs") is not None else None,
            "resources": PipelineResources.from_dict(obj["resources"]) if obj.get("resources") is not None else None
        })
        return _obj

PipelineV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_storage : AnalysisStorageV4

The type of the None singleton.

var code : str

The type of the None singleton.

var description : str

The type of the None singleton.

var id : str

The type of the None singleton.

var input_form_type : str | None

The type of the None singleton.

var language : str

The type of the None singleton.

var language_version : PipelineLanguageVersion | None

The type of the None singleton.

var model_config

The type of the None singleton.

var owner : UserIdentifier

The type of the None singleton.

var pipeline_tags : PipelineTag

The type of the None singleton.

var proprietary : bool | None

The type of the None singleton.

var report_configs : PipelineReportConfig | None

The type of the None singleton.

var resources : PipelineResources | None

The type of the None singleton.

var status : str | None

The type of the None singleton.

var tenant : TenantIdentifier

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var urn : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of PipelineV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of PipelineV4 from a JSON string

def input_form_type_validate_enum(value)

Validates the enum

def language_validate_enum(value)

Validates the enum

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of owner
    if self.owner:
        _dict['owner'] = self.owner.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tenant
    if self.tenant:
        _dict['tenant'] = self.tenant.to_dict()
    # override the default output from pydantic by calling `to_dict()` of language_version
    if self.language_version:
        _dict['languageVersion'] = self.language_version.to_dict()
    # override the default output from pydantic by calling `to_dict()` of pipeline_tags
    if self.pipeline_tags:
        _dict['pipelineTags'] = self.pipeline_tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of analysis_storage
    if self.analysis_storage:
        _dict['analysisStorage'] = self.analysis_storage.to_dict()
    # override the default output from pydantic by calling `to_dict()` of report_configs
    if self.report_configs:
        _dict['reportConfigs'] = self.report_configs.to_dict()
    # override the default output from pydantic by calling `to_dict()` of resources
    if self.resources:
        _dict['resources'] = self.resources.to_dict()
    # set to None if urn (nullable) is None
    # and model_fields_set contains the field
    if self.urn is None and "urn" in self.model_fields_set:
        _dict['urn'] = None

    # set to None if status (nullable) is None
    # and model_fields_set contains the field
    if self.status is None and "status" in self.model_fields_set:
        _dict['status'] = None

    # set to None if language_version (nullable) is None
    # and model_fields_set contains the field
    if self.language_version is None and "language_version" in self.model_fields_set:
        _dict['languageVersion'] = None

    # set to None if proprietary (nullable) is None
    # and model_fields_set contains the field
    if self.proprietary is None and "proprietary" in self.model_fields_set:
        _dict['proprietary'] = None

    # set to None if report_configs (nullable) is None
    # and model_fields_set contains the field
    if self.report_configs is None and "report_configs" in self.model_fields_set:
        _dict['reportConfigs'] = None

    # set to None if resources (nullable) is None
    # and model_fields_set contains the field
    if self.resources is None and "resources" in self.model_fields_set:
        _dict['resources'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Problem (**data: Any)

Expand source code

class Problem(BaseModel):
    """
    RFC 7807 Problem object (https://tools.ietf.org/html/rfc7807)
    """ # noqa: E501
    id: Optional[StrictStr] = None
    type: StrictStr = Field(description="A URI reference that identifies the problem type. This specification encourages that, when dereferenced, it provide human-readable documentation for the problem type. When this member is not present, its value is assumed to be \"about:blank\".")
    title: StrictStr = Field(description="A short, human-readable summary of the problem type. It SHOULD NOT change from occurrence to occurrence of the problem, except for purposes of localization (e.g., using proactive content negotiation;")
    status: StrictInt = Field(description="The HTTP status code ([RFC7231], Section 6) generated by the origin server for this occurrence of the problem.")
    detail: Optional[StrictStr] = Field(default=None, description="A human-readable explanation specific to this occurrence of the problem.")
    instance: Optional[StrictStr] = Field(default=None, description="A URI reference that identifies the specific occurrence of the problem.  It may or may not yield further information if dereferenced.")
    parameters: Dict[str, StrictStr] = Field(description="Problem parameters for e.g. request body attribute validation. This attribute is not in scope of RFC 7807.")
    timestamp: datetime
    __properties: ClassVar[List[str]] = ["id", "type", "title", "status", "detail", "instance", "parameters", "timestamp"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Problem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Problem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "type": obj.get("type"),
            "title": obj.get("title"),
            "status": obj.get("status"),
            "detail": obj.get("detail"),
            "instance": obj.get("instance"),
            "parameters": obj.get("parameters"),
            "timestamp": obj.get("timestamp")
        })
        return _obj

RFC 7807 Problem object (https://tools.ietf.org/html/rfc7807)

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var detail : str | None

The type of the None singleton.

var id : str | None

The type of the None singleton.

var instance : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var parameters : Dict[str, str]

The type of the None singleton.

var status : int

The type of the None singleton.

var timestamp : datetime.datetime

The type of the None singleton.

var title : str

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Problem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Problem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Project (**data: Any)

Expand source code

class Project(BaseModel):
    """
    Project
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    urn: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=2000)]] = Field(default=None, description="The URN of the project. The format is urn:ilmn:ica:\\<type of the object\\>:\\<ID of the object\\>#\\<optional human readable hint representing the object\\>. The hint can be omitted, in that case the hashtag (#) must also be omitted.")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    active: StrictBool = Field(description="Indicates whether the project is active or hidden.")
    base_enabled: Optional[StrictBool] = Field(default=None, description="Indicates whether the project is base enabled.", alias="baseEnabled")
    short_description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = Field(default=None, alias="shortDescription")
    information: Optional[StrictStr] = Field(default=None, description="Information about the project. Note that the value of this field can be arbitrary large.")
    region: Region
    billing_mode: StrictStr = Field(description="The billing mode of the project. It determines who pays for the costs linked to the project.", alias="billingMode")
    data_sharing_enabled: Optional[StrictBool] = Field(default=None, description="Indicates whether the Data and Samples created in this Project can be linked to other Projects.", alias="dataSharingEnabled")
    tags: ProjectTag
    storage_bundle: Optional[StorageBundle] = Field(default=None, alias="storageBundle")
    self_managed_storage_configuration: Optional[StorageConfiguration] = Field(default=None, alias="selfManagedStorageConfiguration")
    analysis_priority: Optional[StrictStr] = Field(default=None, description="Indicates the priority given to a project and its analyses within a single tenant. Note that for a PUT call, when not providing a value for this attribute (null value or absent attribute), the persisted value will not change.", alias="analysisPriority")
    metadata_model: Optional[MetadataModel] = Field(default=None, alias="metadataModel")
    application: Optional[Application] = None
    project_owner: Optional[StrictStr] = Field(default=None, description="projectOwner is the current project owner, ownerId is the original project creator. These can be different because you can transfer ownership of a project.", alias="projectOwner")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "urn", "name", "active", "baseEnabled", "shortDescription", "information", "region", "billingMode", "dataSharingEnabled", "tags", "storageBundle", "selfManagedStorageConfiguration", "analysisPriority", "metadataModel", "application", "projectOwner"]

    @field_validator('billing_mode')
    def billing_mode_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['PROJECT', 'TENANT']):
            raise ValueError("must be one of enum values ('PROJECT', 'TENANT')")
        return value

    @field_validator('analysis_priority')
    def analysis_priority_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['LOW', 'MEDIUM', 'HIGH']):
            raise ValueError("must be one of enum values ('LOW', 'MEDIUM', 'HIGH')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Project from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of region
        if self.region:
            _dict['region'] = self.region.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of storage_bundle
        if self.storage_bundle:
            _dict['storageBundle'] = self.storage_bundle.to_dict()
        # override the default output from pydantic by calling `to_dict()` of self_managed_storage_configuration
        if self.self_managed_storage_configuration:
            _dict['selfManagedStorageConfiguration'] = self.self_managed_storage_configuration.to_dict()
        # override the default output from pydantic by calling `to_dict()` of metadata_model
        if self.metadata_model:
            _dict['metadataModel'] = self.metadata_model.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if urn (nullable) is None
        # and model_fields_set contains the field
        if self.urn is None and "urn" in self.model_fields_set:
            _dict['urn'] = None

        # set to None if base_enabled (nullable) is None
        # and model_fields_set contains the field
        if self.base_enabled is None and "base_enabled" in self.model_fields_set:
            _dict['baseEnabled'] = None

        # set to None if short_description (nullable) is None
        # and model_fields_set contains the field
        if self.short_description is None and "short_description" in self.model_fields_set:
            _dict['shortDescription'] = None

        # set to None if information (nullable) is None
        # and model_fields_set contains the field
        if self.information is None and "information" in self.model_fields_set:
            _dict['information'] = None

        # set to None if data_sharing_enabled (nullable) is None
        # and model_fields_set contains the field
        if self.data_sharing_enabled is None and "data_sharing_enabled" in self.model_fields_set:
            _dict['dataSharingEnabled'] = None

        # set to None if analysis_priority (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_priority is None and "analysis_priority" in self.model_fields_set:
            _dict['analysisPriority'] = None

        # set to None if metadata_model (nullable) is None
        # and model_fields_set contains the field
        if self.metadata_model is None and "metadata_model" in self.model_fields_set:
            _dict['metadataModel'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        # set to None if project_owner (nullable) is None
        # and model_fields_set contains the field
        if self.project_owner is None and "project_owner" in self.model_fields_set:
            _dict['projectOwner'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Project from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "urn": obj.get("urn"),
            "name": obj.get("name"),
            "active": obj.get("active"),
            "baseEnabled": obj.get("baseEnabled"),
            "shortDescription": obj.get("shortDescription"),
            "information": obj.get("information"),
            "region": Region.from_dict(obj["region"]) if obj.get("region") is not None else None,
            "billingMode": obj.get("billingMode"),
            "dataSharingEnabled": obj.get("dataSharingEnabled"),
            "tags": ProjectTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "storageBundle": StorageBundle.from_dict(obj["storageBundle"]) if obj.get("storageBundle") is not None else None,
            "selfManagedStorageConfiguration": StorageConfiguration.from_dict(obj["selfManagedStorageConfiguration"]) if obj.get("selfManagedStorageConfiguration") is not None else None,
            "analysisPriority": obj.get("analysisPriority"),
            "metadataModel": MetadataModel.from_dict(obj["metadataModel"]) if obj.get("metadataModel") is not None else None,
            "application": Application.from_dict(obj["application"]) if obj.get("application") is not None else None,
            "projectOwner": obj.get("projectOwner")
        })
        return _obj

Project

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var active : bool

The type of the None singleton.

var analysis_priority : str | None

The type of the None singleton.

var application : Application | None

The type of the None singleton.

var base_enabled : bool | None

The type of the None singleton.

var billing_mode : str

The type of the None singleton.

var data_sharing_enabled : bool | None

The type of the None singleton.

var id : str

The type of the None singleton.

var information : str | None

The type of the None singleton.

var metadata_model : MetadataModel | None

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var project_owner : str | None

The type of the None singleton.

var region : Region

The type of the None singleton.

var self_managed_storage_configuration : StorageConfiguration | None

The type of the None singleton.

var short_description : str | None

The type of the None singleton.

var storage_bundle : StorageBundle | None

The type of the None singleton.

var tags : ProjectTag

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var urn : str | None

The type of the None singleton.

Static methods

def analysis_priority_validate_enum(value)

Validates the enum

def billing_mode_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Project from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Project from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of region
    if self.region:
        _dict['region'] = self.region.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of storage_bundle
    if self.storage_bundle:
        _dict['storageBundle'] = self.storage_bundle.to_dict()
    # override the default output from pydantic by calling `to_dict()` of self_managed_storage_configuration
    if self.self_managed_storage_configuration:
        _dict['selfManagedStorageConfiguration'] = self.self_managed_storage_configuration.to_dict()
    # override the default output from pydantic by calling `to_dict()` of metadata_model
    if self.metadata_model:
        _dict['metadataModel'] = self.metadata_model.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if urn (nullable) is None
    # and model_fields_set contains the field
    if self.urn is None and "urn" in self.model_fields_set:
        _dict['urn'] = None

    # set to None if base_enabled (nullable) is None
    # and model_fields_set contains the field
    if self.base_enabled is None and "base_enabled" in self.model_fields_set:
        _dict['baseEnabled'] = None

    # set to None if short_description (nullable) is None
    # and model_fields_set contains the field
    if self.short_description is None and "short_description" in self.model_fields_set:
        _dict['shortDescription'] = None

    # set to None if information (nullable) is None
    # and model_fields_set contains the field
    if self.information is None and "information" in self.model_fields_set:
        _dict['information'] = None

    # set to None if data_sharing_enabled (nullable) is None
    # and model_fields_set contains the field
    if self.data_sharing_enabled is None and "data_sharing_enabled" in self.model_fields_set:
        _dict['dataSharingEnabled'] = None

    # set to None if analysis_priority (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_priority is None and "analysis_priority" in self.model_fields_set:
        _dict['analysisPriority'] = None

    # set to None if metadata_model (nullable) is None
    # and model_fields_set contains the field
    if self.metadata_model is None and "metadata_model" in self.model_fields_set:
        _dict['metadataModel'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    # set to None if project_owner (nullable) is None
    # and model_fields_set contains the field
    if self.project_owner is None and "project_owner" in self.model_fields_set:
        _dict['projectOwner'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectAnalysisApi (api_client=None)

Expand source code

class ProjectAnalysisApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def abort_analysis(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to abort")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Abort an analysis.

        Endpoint for aborting an analysis. The status of the analysis is not updated immediately, only when the abortion of the analysis has actually started.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to abort (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._abort_analysis_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def abort_analysis_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to abort")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Abort an analysis.

        Endpoint for aborting an analysis. The status of the analysis is not updated immediately, only when the abortion of the analysis has actually started.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to abort (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._abort_analysis_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def abort_analysis_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to abort")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Abort an analysis.

        Endpoint for aborting an analysis. The status of the analysis is not updated immediately, only when the abortion of the analysis has actually started.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to abort (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._abort_analysis_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _abort_analysis_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}:abort',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_cwl_analysis(
        self,
        project_id: StrictStr,
        create_cwl_analysis: Annotated[CreateCwlAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisV4:
        """(Deprecated) Create and start an analysis for a CWL pipeline.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param create_cwl_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_analysis: CreateCwlAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("POST /api/projects/{projectId}/analysis:cwl is deprecated.", DeprecationWarning)

        _param = self._create_cwl_analysis_serialize(
            project_id=project_id,
            create_cwl_analysis=create_cwl_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_cwl_analysis_with_http_info(
        self,
        project_id: StrictStr,
        create_cwl_analysis: Annotated[CreateCwlAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisV4]:
        """(Deprecated) Create and start an analysis for a CWL pipeline.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param create_cwl_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_analysis: CreateCwlAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("POST /api/projects/{projectId}/analysis:cwl is deprecated.", DeprecationWarning)

        _param = self._create_cwl_analysis_serialize(
            project_id=project_id,
            create_cwl_analysis=create_cwl_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_cwl_analysis_without_preload_content(
        self,
        project_id: StrictStr,
        create_cwl_analysis: Annotated[CreateCwlAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """(Deprecated) Create and start an analysis for a CWL pipeline.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param create_cwl_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_analysis: CreateCwlAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("POST /api/projects/{projectId}/analysis:cwl is deprecated.", DeprecationWarning)

        _param = self._create_cwl_analysis_serialize(
            project_id=project_id,
            create_cwl_analysis=create_cwl_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_cwl_analysis_serialize(
        self,
        project_id,
        create_cwl_analysis,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_cwl_analysis is not None:
            _body_params = create_cwl_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json', 
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analysis:cwl',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_cwl_analysis_with_json_input(
        self,
        project_id: StrictStr,
        create_cwl_with_json_input_analysis: Annotated[CreateCwlWithJsonInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisV4:
        """Create and start an analysis for a CWL pipeline with an input.json.

        This endpoint is intended to be used with an input.json and will bypass the input form. The combination of using this endpoint with an input.json for a json-form based pipeline with sensitive fields defined is not possible.

        :param project_id: (required)
        :type project_id: str
        :param create_cwl_with_json_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_with_json_input_analysis: CreateCwlWithJsonInputAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_analysis_with_json_input_serialize(
            project_id=project_id,
            create_cwl_with_json_input_analysis=create_cwl_with_json_input_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_cwl_analysis_with_json_input_with_http_info(
        self,
        project_id: StrictStr,
        create_cwl_with_json_input_analysis: Annotated[CreateCwlWithJsonInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisV4]:
        """Create and start an analysis for a CWL pipeline with an input.json.

        This endpoint is intended to be used with an input.json and will bypass the input form. The combination of using this endpoint with an input.json for a json-form based pipeline with sensitive fields defined is not possible.

        :param project_id: (required)
        :type project_id: str
        :param create_cwl_with_json_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_with_json_input_analysis: CreateCwlWithJsonInputAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_analysis_with_json_input_serialize(
            project_id=project_id,
            create_cwl_with_json_input_analysis=create_cwl_with_json_input_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_cwl_analysis_with_json_input_without_preload_content(
        self,
        project_id: StrictStr,
        create_cwl_with_json_input_analysis: Annotated[CreateCwlWithJsonInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create and start an analysis for a CWL pipeline with an input.json.

        This endpoint is intended to be used with an input.json and will bypass the input form. The combination of using this endpoint with an input.json for a json-form based pipeline with sensitive fields defined is not possible.

        :param project_id: (required)
        :type project_id: str
        :param create_cwl_with_json_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_with_json_input_analysis: CreateCwlWithJsonInputAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_analysis_with_json_input_serialize(
            project_id=project_id,
            create_cwl_with_json_input_analysis=create_cwl_with_json_input_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_cwl_analysis_with_json_input_serialize(
        self,
        project_id,
        create_cwl_with_json_input_analysis,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_cwl_with_json_input_analysis is not None:
            _body_params = create_cwl_with_json_input_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analysis:cwlWithJsonInput',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_cwl_analysis_with_structured_input(
        self,
        project_id: StrictStr,
        create_cwl_with_structured_input_analysis: Annotated[CreateCwlWithStructuredInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisV4:
        """Create and start an analysis for a CWL pipeline with a structured input.


        :param project_id: (required)
        :type project_id: str
        :param create_cwl_with_structured_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_with_structured_input_analysis: CreateCwlWithStructuredInputAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_analysis_with_structured_input_serialize(
            project_id=project_id,
            create_cwl_with_structured_input_analysis=create_cwl_with_structured_input_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_cwl_analysis_with_structured_input_with_http_info(
        self,
        project_id: StrictStr,
        create_cwl_with_structured_input_analysis: Annotated[CreateCwlWithStructuredInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisV4]:
        """Create and start an analysis for a CWL pipeline with a structured input.


        :param project_id: (required)
        :type project_id: str
        :param create_cwl_with_structured_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_with_structured_input_analysis: CreateCwlWithStructuredInputAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_analysis_with_structured_input_serialize(
            project_id=project_id,
            create_cwl_with_structured_input_analysis=create_cwl_with_structured_input_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_cwl_analysis_with_structured_input_without_preload_content(
        self,
        project_id: StrictStr,
        create_cwl_with_structured_input_analysis: Annotated[CreateCwlWithStructuredInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create and start an analysis for a CWL pipeline with a structured input.


        :param project_id: (required)
        :type project_id: str
        :param create_cwl_with_structured_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_with_structured_input_analysis: CreateCwlWithStructuredInputAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_analysis_with_structured_input_serialize(
            project_id=project_id,
            create_cwl_with_structured_input_analysis=create_cwl_with_structured_input_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_cwl_analysis_with_structured_input_serialize(
        self,
        project_id,
        create_cwl_with_structured_input_analysis,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_cwl_with_structured_input_analysis is not None:
            _body_params = create_cwl_with_structured_input_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analysis:cwlWithStructuredInput',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_cwl_json_analysis(
        self,
        project_id: StrictStr,
        create_cwl_json_analysis: Annotated[CreateCwlJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisV4:
        """Create and start an analysis for a JSON based CWL pipeline.


        :param project_id: (required)
        :type project_id: str
        :param create_cwl_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_json_analysis: CreateCwlJsonAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_json_analysis_serialize(
            project_id=project_id,
            create_cwl_json_analysis=create_cwl_json_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_cwl_json_analysis_with_http_info(
        self,
        project_id: StrictStr,
        create_cwl_json_analysis: Annotated[CreateCwlJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisV4]:
        """Create and start an analysis for a JSON based CWL pipeline.


        :param project_id: (required)
        :type project_id: str
        :param create_cwl_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_json_analysis: CreateCwlJsonAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_json_analysis_serialize(
            project_id=project_id,
            create_cwl_json_analysis=create_cwl_json_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_cwl_json_analysis_without_preload_content(
        self,
        project_id: StrictStr,
        create_cwl_json_analysis: Annotated[CreateCwlJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create and start an analysis for a JSON based CWL pipeline.


        :param project_id: (required)
        :type project_id: str
        :param create_cwl_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_cwl_json_analysis: CreateCwlJsonAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_json_analysis_serialize(
            project_id=project_id,
            create_cwl_json_analysis=create_cwl_json_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_cwl_json_analysis_serialize(
        self,
        project_id,
        create_cwl_json_analysis,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_cwl_json_analysis is not None:
            _body_params = create_cwl_json_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analysis:cwlJson',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_nextflow_analysis(
        self,
        project_id: StrictStr,
        create_nextflow_analysis: Annotated[CreateNextflowAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisV4:
        """Create and start an analysis for a Nextflow pipeline.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param create_nextflow_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_nextflow_analysis: CreateNextflowAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_analysis_serialize(
            project_id=project_id,
            create_nextflow_analysis=create_nextflow_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_nextflow_analysis_with_http_info(
        self,
        project_id: StrictStr,
        create_nextflow_analysis: Annotated[CreateNextflowAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisV4]:
        """Create and start an analysis for a Nextflow pipeline.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param create_nextflow_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_nextflow_analysis: CreateNextflowAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_analysis_serialize(
            project_id=project_id,
            create_nextflow_analysis=create_nextflow_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_nextflow_analysis_without_preload_content(
        self,
        project_id: StrictStr,
        create_nextflow_analysis: Annotated[CreateNextflowAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create and start an analysis for a Nextflow pipeline.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param create_nextflow_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_nextflow_analysis: CreateNextflowAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_analysis_serialize(
            project_id=project_id,
            create_nextflow_analysis=create_nextflow_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_nextflow_analysis_serialize(
        self,
        project_id,
        create_nextflow_analysis,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_nextflow_analysis is not None:
            _body_params = create_nextflow_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json', 
                        'application/vnd.illumina.v3+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analysis:nextflow',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_nextflow_analysis_with_custom_input(
        self,
        project_id: StrictStr,
        create_nextflow_with_custom_input_analysis: Annotated[CreateNextflowWithCustomInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisV4:
        """Create and initiate an analysis for a Nextflow pipeline using a custom input, provided in either YAML format or an escaped JSON string.

        This endpoint is intended to be used with a custom input and will bypass the input form. The combination of using this endpoint with a custom input for a json-form based pipeline with sensitive fields defined is not possible.

        :param project_id: (required)
        :type project_id: str
        :param create_nextflow_with_custom_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_nextflow_with_custom_input_analysis: CreateNextflowWithCustomInputAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_analysis_with_custom_input_serialize(
            project_id=project_id,
            create_nextflow_with_custom_input_analysis=create_nextflow_with_custom_input_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_nextflow_analysis_with_custom_input_with_http_info(
        self,
        project_id: StrictStr,
        create_nextflow_with_custom_input_analysis: Annotated[CreateNextflowWithCustomInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisV4]:
        """Create and initiate an analysis for a Nextflow pipeline using a custom input, provided in either YAML format or an escaped JSON string.

        This endpoint is intended to be used with a custom input and will bypass the input form. The combination of using this endpoint with a custom input for a json-form based pipeline with sensitive fields defined is not possible.

        :param project_id: (required)
        :type project_id: str
        :param create_nextflow_with_custom_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_nextflow_with_custom_input_analysis: CreateNextflowWithCustomInputAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_analysis_with_custom_input_serialize(
            project_id=project_id,
            create_nextflow_with_custom_input_analysis=create_nextflow_with_custom_input_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_nextflow_analysis_with_custom_input_without_preload_content(
        self,
        project_id: StrictStr,
        create_nextflow_with_custom_input_analysis: Annotated[CreateNextflowWithCustomInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create and initiate an analysis for a Nextflow pipeline using a custom input, provided in either YAML format or an escaped JSON string.

        This endpoint is intended to be used with a custom input and will bypass the input form. The combination of using this endpoint with a custom input for a json-form based pipeline with sensitive fields defined is not possible.

        :param project_id: (required)
        :type project_id: str
        :param create_nextflow_with_custom_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_nextflow_with_custom_input_analysis: CreateNextflowWithCustomInputAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_analysis_with_custom_input_serialize(
            project_id=project_id,
            create_nextflow_with_custom_input_analysis=create_nextflow_with_custom_input_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_nextflow_analysis_with_custom_input_serialize(
        self,
        project_id,
        create_nextflow_with_custom_input_analysis,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_nextflow_with_custom_input_analysis is not None:
            _body_params = create_nextflow_with_custom_input_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analysis:nextflowWithCustomInput',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_nextflow_json_analysis(
        self,
        project_id: StrictStr,
        create_nextflow_json_analysis: Annotated[CreateNextflowJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisV4:
        """Create and start an analysis for a JSON based Nextflow pipeline.


        :param project_id: (required)
        :type project_id: str
        :param create_nextflow_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_nextflow_json_analysis: CreateNextflowJsonAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_json_analysis_serialize(
            project_id=project_id,
            create_nextflow_json_analysis=create_nextflow_json_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_nextflow_json_analysis_with_http_info(
        self,
        project_id: StrictStr,
        create_nextflow_json_analysis: Annotated[CreateNextflowJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisV4]:
        """Create and start an analysis for a JSON based Nextflow pipeline.


        :param project_id: (required)
        :type project_id: str
        :param create_nextflow_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_nextflow_json_analysis: CreateNextflowJsonAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_json_analysis_serialize(
            project_id=project_id,
            create_nextflow_json_analysis=create_nextflow_json_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_nextflow_json_analysis_without_preload_content(
        self,
        project_id: StrictStr,
        create_nextflow_json_analysis: Annotated[CreateNextflowJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create and start an analysis for a JSON based Nextflow pipeline.


        :param project_id: (required)
        :type project_id: str
        :param create_nextflow_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
        :type create_nextflow_json_analysis: CreateNextflowJsonAnalysis
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_json_analysis_serialize(
            project_id=project_id,
            create_nextflow_json_analysis=create_nextflow_json_analysis,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_nextflow_json_analysis_serialize(
        self,
        project_id,
        create_nextflow_json_analysis,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_nextflow_json_analysis is not None:
            _body_params = create_nextflow_json_analysis


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analysis:nextflowJson',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analyses(
        self,
        project_id: StrictStr,
        reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
        userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
        technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
        referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisPagedListV3:
        """(Deprecated) Retrieve the list of analyses.

        This endpoint only returns V3 items. Use the search endpoint to get V4 items.

        :param project_id: (required)
        :type project_id: str
        :param reference: The reference to filter on.
        :type reference: str
        :param userreference: The user-reference to filter on.
        :type userreference: str
        :param status: The status to filter on.
        :type status: str
        :param usertag: The user-tags to filter on.
        :type usertag: str
        :param technicaltag: The technical-tags to filter on.
        :type technicaltag: str
        :param referencetag: The reference-data-tags to filter on.
        :type referencetag: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/analyses is deprecated.", DeprecationWarning)

        _param = self._get_analyses_serialize(
            project_id=project_id,
            reference=reference,
            userreference=userreference,
            status=status,
            usertag=usertag,
            technicaltag=technicaltag,
            referencetag=referencetag,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analyses_with_http_info(
        self,
        project_id: StrictStr,
        reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
        userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
        technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
        referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisPagedListV3]:
        """(Deprecated) Retrieve the list of analyses.

        This endpoint only returns V3 items. Use the search endpoint to get V4 items.

        :param project_id: (required)
        :type project_id: str
        :param reference: The reference to filter on.
        :type reference: str
        :param userreference: The user-reference to filter on.
        :type userreference: str
        :param status: The status to filter on.
        :type status: str
        :param usertag: The user-tags to filter on.
        :type usertag: str
        :param technicaltag: The technical-tags to filter on.
        :type technicaltag: str
        :param referencetag: The reference-data-tags to filter on.
        :type referencetag: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/analyses is deprecated.", DeprecationWarning)

        _param = self._get_analyses_serialize(
            project_id=project_id,
            reference=reference,
            userreference=userreference,
            status=status,
            usertag=usertag,
            technicaltag=technicaltag,
            referencetag=referencetag,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analyses_without_preload_content(
        self,
        project_id: StrictStr,
        reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
        userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
        technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
        referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """(Deprecated) Retrieve the list of analyses.

        This endpoint only returns V3 items. Use the search endpoint to get V4 items.

        :param project_id: (required)
        :type project_id: str
        :param reference: The reference to filter on.
        :type reference: str
        :param userreference: The user-reference to filter on.
        :type userreference: str
        :param status: The status to filter on.
        :type status: str
        :param usertag: The user-tags to filter on.
        :type usertag: str
        :param technicaltag: The technical-tags to filter on.
        :type technicaltag: str
        :param referencetag: The reference-data-tags to filter on.
        :type referencetag: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/analyses is deprecated.", DeprecationWarning)

        _param = self._get_analyses_serialize(
            project_id=project_id,
            reference=reference,
            userreference=userreference,
            status=status,
            usertag=usertag,
            technicaltag=technicaltag,
            referencetag=referencetag,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analyses_serialize(
        self,
        project_id,
        reference,
        userreference,
        status,
        usertag,
        technicaltag,
        referencetag,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if reference is not None:
            
            _query_params.append(('reference', reference))
            
        if userreference is not None:
            
            _query_params.append(('userreference', userreference))
            
        if status is not None:
            
            _query_params.append(('status', status))
            
        if usertag is not None:
            
            _query_params.append(('usertag', usertag))
            
        if technicaltag is not None:
            
            _query_params.append(('technicaltag', technicaltag))
            
        if referencetag is not None:
            
            _query_params.append(('referencetag', referencetag))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisV4:
        """Retrieve an analysis.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisV4]:
        """Retrieve an analysis.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve an analysis.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis_configurations(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the configuration for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ExecutionConfigurationList:
        """Retrieve the configurations of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the configuration for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_configurations_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ExecutionConfigurationList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_configurations_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the configuration for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ExecutionConfigurationList]:
        """Retrieve the configurations of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the configuration for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_configurations_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ExecutionConfigurationList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_configurations_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the configuration for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the configurations of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the configuration for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_configurations_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ExecutionConfigurationList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_configurations_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/configurations',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis_inputs(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the inputs for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisInputList:
        """Retrieve the inputs of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the inputs for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_inputs_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisInputList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_inputs_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the inputs for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisInputList]:
        """Retrieve the inputs of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the inputs for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_inputs_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisInputList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_inputs_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the inputs for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the inputs of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the inputs for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_inputs_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisInputList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_inputs_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/inputs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis_outputs(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the outputs for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisOutputList:
        """Retrieve the outputs of an analysis (limited to the first 200.000 files per output folder). When trying to retrieve the listed data with an endpoint such as GET /api/data/{dataUrn}, data which has already been deleted will be skipped.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the outputs for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_outputs_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisOutputList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_outputs_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the outputs for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisOutputList]:
        """Retrieve the outputs of an analysis (limited to the first 200.000 files per output folder). When trying to retrieve the listed data with an endpoint such as GET /api/data/{dataUrn}, data which has already been deleted will be skipped.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the outputs for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_outputs_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisOutputList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_outputs_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the outputs for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the outputs of an analysis (limited to the first 200.000 files per output folder). When trying to retrieve the listed data with an endpoint such as GET /api/data/{dataUrn}, data which has already been deleted will be skipped.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the outputs for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_outputs_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisOutputList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_outputs_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/outputs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis_reports(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the reports for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisReportEntryList:
        """Retrieve the report configs and associated reports.

        Retrieves the reports which match the report config defined in a pipeline.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the reports for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_reports_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisReportEntryList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_reports_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the reports for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisReportEntryList]:
        """Retrieve the report configs and associated reports.

        Retrieves the reports which match the report config defined in a pipeline.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the reports for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_reports_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisReportEntryList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_reports_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the reports for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the report configs and associated reports.

        Retrieves the reports which match the report config defined in a pipeline.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the reports for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_reports_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisReportEntryList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_reports_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/reports',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis_steps(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the individual steps for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisStepList:
        """Retrieve the individual steps of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the individual steps for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_steps_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisStepList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_steps_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the individual steps for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisStepList]:
        """Retrieve the individual steps of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the individual steps for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_steps_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisStepList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_steps_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the individual steps for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the individual steps of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the individual steps for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_steps_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisStepList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_steps_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/steps',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis_usage_details(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the usage details for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisUsageDetails:
        """Retrieve the analysis usage details.

        The usage details can be retrieved once the analysis has completed with status SUCCEEDED or FAILED. It may take several minutes for the information to become available. A 404 status indicates that the system is busy processing the information.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the usage details for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_usage_details_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisUsageDetails",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_usage_details_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the usage details for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisUsageDetails]:
        """Retrieve the analysis usage details.

        The usage details can be retrieved once the analysis has completed with status SUCCEEDED or FAILED. It may take several minutes for the information to become available. A 404 status indicates that the system is busy processing the information.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the usage details for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_usage_details_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisUsageDetails",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_usage_details_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the usage details for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the analysis usage details.

        The usage details can be retrieved once the analysis has completed with status SUCCEEDED or FAILED. It may take several minutes for the information to become available. A 404 status indicates that the system is busy processing the information.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the usage details for (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_usage_details_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisUsageDetails",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_usage_details_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/usage',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_cwl_input_json(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the input json")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> CwlAnalysisInputJson:
        """Retrieve the input json of a CWL analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the CWL analysis for which to retrieve the input json (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_cwl_input_json_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CwlAnalysisInputJson",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_cwl_input_json_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the input json")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[CwlAnalysisInputJson]:
        """Retrieve the input json of a CWL analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the CWL analysis for which to retrieve the input json (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_cwl_input_json_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CwlAnalysisInputJson",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_cwl_input_json_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the input json")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the input json of a CWL analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the CWL analysis for which to retrieve the input json (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_cwl_input_json_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CwlAnalysisInputJson",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_cwl_input_json_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/cwl/inputJson',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_cwl_output_json(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the output json")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> CwlAnalysisOutputJson:
        """Retrieve the output json of a CWL analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the CWL analysis for which to retrieve the output json (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_cwl_output_json_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CwlAnalysisOutputJson",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_cwl_output_json_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the output json")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[CwlAnalysisOutputJson]:
        """Retrieve the output json of a CWL analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the CWL analysis for which to retrieve the output json (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_cwl_output_json_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CwlAnalysisOutputJson",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_cwl_output_json_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the output json")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the output json of a CWL analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the CWL analysis for which to retrieve the output json (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_cwl_output_json_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CwlAnalysisOutputJson",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_cwl_output_json_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/cwl/outputJson',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_analysis_input_form_values(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the input form values from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> InputFormFieldList:
        """Retrieve the values from an input form.

        Retrieve the values from an input form of a JSON based pipeline used to start an analysis.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the input form values from (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_analysis_input_form_values_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InputFormFieldList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_analysis_input_form_values_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the input form values from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[InputFormFieldList]:
        """Retrieve the values from an input form.

        Retrieve the values from an input form of a JSON based pipeline used to start an analysis.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the input form values from (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_analysis_input_form_values_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InputFormFieldList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_analysis_input_form_values_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the input form values from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the values from an input form.

        Retrieve the values from an input form of a JSON based pipeline used to start an analysis.

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis to retrieve the input form values from (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_analysis_input_form_values_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InputFormFieldList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_analysis_input_form_values_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/inputFormValues',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_raw_analysis_output(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis for which to retrieve the raw output")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisRawOutput:
        """(Deprecated) Retrieve the raw output of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis for which to retrieve the raw output (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/analyses/{analysisId}/rawOutput is deprecated.", DeprecationWarning)

        _param = self._get_raw_analysis_output_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisRawOutput",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_raw_analysis_output_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis for which to retrieve the raw output")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisRawOutput]:
        """(Deprecated) Retrieve the raw output of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis for which to retrieve the raw output (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/analyses/{analysisId}/rawOutput is deprecated.", DeprecationWarning)

        _param = self._get_raw_analysis_output_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisRawOutput",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_raw_analysis_output_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis for which to retrieve the raw output")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """(Deprecated) Retrieve the raw output of an analysis.


        :param project_id: (required)
        :type project_id: str
        :param analysis_id: The ID of the analysis for which to retrieve the raw output (required)
        :type analysis_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/analyses/{analysisId}/rawOutput is deprecated.", DeprecationWarning)

        _param = self._get_raw_analysis_output_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisRawOutput",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_raw_analysis_output_serialize(
        self,
        project_id,
        analysis_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}/rawOutput',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def search_analyses(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisPagedListV4:
        """Search analyses.


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_analyses_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def search_analyses_with_http_info(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisPagedListV4]:
        """Search analyses.


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_analyses_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def search_analyses_without_preload_content(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Search analyses.


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_analyses_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _search_analyses_serialize(
        self,
        project_id,
        page_offset,
        page_token,
        page_size,
        sort,
        analysis_query_parameters,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if analysis_query_parameters is not None:
            _body_params = analysis_query_parameters


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analysis:search',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_analysis(
        self,
        project_id: StrictStr,
        analysis_id: StrictStr,
        analysis_v4: AnalysisV4,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisV4:
        """Update an analysis.

        # Attributes which can be updated:    - tags # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: (required)
        :type analysis_id: str
        :param analysis_v4: (required)
        :type analysis_v4: AnalysisV4
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_analysis_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            analysis_v4=analysis_v4,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_analysis_with_http_info(
        self,
        project_id: StrictStr,
        analysis_id: StrictStr,
        analysis_v4: AnalysisV4,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisV4]:
        """Update an analysis.

        # Attributes which can be updated:    - tags # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: (required)
        :type analysis_id: str
        :param analysis_v4: (required)
        :type analysis_v4: AnalysisV4
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_analysis_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            analysis_v4=analysis_v4,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_analysis_without_preload_content(
        self,
        project_id: StrictStr,
        analysis_id: StrictStr,
        analysis_v4: AnalysisV4,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update an analysis.

        # Attributes which can be updated:    - tags # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param analysis_id: (required)
        :type analysis_id: str
        :param analysis_v4: (required)
        :type analysis_v4: AnalysisV4
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_analysis_serialize(
            project_id=project_id,
            analysis_id=analysis_id,
            analysis_v4=analysis_v4,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_analysis_serialize(
        self,
        project_id,
        analysis_id,
        analysis_v4,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if analysis_id is not None:
            _path_params['analysisId'] = analysis_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if analysis_v4 is not None:
            _body_params = analysis_v4


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json', 
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/analyses/{analysisId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def abort_analysis(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to abort')]) ‑> None

Expand source code

@validate_call
def abort_analysis(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to abort")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Abort an analysis.

    Endpoint for aborting an analysis. The status of the analysis is not updated immediately, only when the abortion of the analysis has actually started.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to abort (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._abort_analysis_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Abort an analysis.

Endpoint for aborting an analysis. The status of the analysis is not updated immediately, only when the abortion of the analysis has actually started.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to abort (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def abort_analysis_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to abort')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def abort_analysis_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to abort")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Abort an analysis.

    Endpoint for aborting an analysis. The status of the analysis is not updated immediately, only when the abortion of the analysis has actually started.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to abort (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._abort_analysis_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Abort an analysis.

Endpoint for aborting an analysis. The status of the analysis is not updated immediately, only when the abortion of the analysis has actually started.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to abort (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def abort_analysis_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to abort')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def abort_analysis_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to abort")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Abort an analysis.

    Endpoint for aborting an analysis. The status of the analysis is not updated immediately, only when the abortion of the analysis has actually started.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to abort (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._abort_analysis_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Abort an analysis.

Endpoint for aborting an analysis. The status of the analysis is not updated immediately, only when the abortion of the analysis has actually started.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to abort (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_analysis(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_analysis: Annotated[CreateCwlAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> AnalysisV4

Expand source code

@validate_call
def create_cwl_analysis(
    self,
    project_id: StrictStr,
    create_cwl_analysis: Annotated[CreateCwlAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisV4:
    """(Deprecated) Create and start an analysis for a CWL pipeline.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param create_cwl_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_analysis: CreateCwlAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("POST /api/projects/{projectId}/analysis:cwl is deprecated.", DeprecationWarning)

    _param = self._create_cwl_analysis_serialize(
        project_id=project_id,
        create_cwl_analysis=create_cwl_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

(Deprecated) Create and start an analysis for a CWL pipeline.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param create_cwl_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_analysis: CreateCwlAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_analysis_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_analysis: Annotated[CreateCwlAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[AnalysisV4]

Expand source code

@validate_call
def create_cwl_analysis_with_http_info(
    self,
    project_id: StrictStr,
    create_cwl_analysis: Annotated[CreateCwlAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisV4]:
    """(Deprecated) Create and start an analysis for a CWL pipeline.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param create_cwl_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_analysis: CreateCwlAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("POST /api/projects/{projectId}/analysis:cwl is deprecated.", DeprecationWarning)

    _param = self._create_cwl_analysis_serialize(
        project_id=project_id,
        create_cwl_analysis=create_cwl_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

(Deprecated) Create and start an analysis for a CWL pipeline.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param create_cwl_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_analysis: CreateCwlAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_analysis_with_json_input(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_with_json_input_analysis: Annotated[CreateCwlWithJsonInputAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> AnalysisV4

Expand source code

@validate_call
def create_cwl_analysis_with_json_input(
    self,
    project_id: StrictStr,
    create_cwl_with_json_input_analysis: Annotated[CreateCwlWithJsonInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisV4:
    """Create and start an analysis for a CWL pipeline with an input.json.

    This endpoint is intended to be used with an input.json and will bypass the input form. The combination of using this endpoint with an input.json for a json-form based pipeline with sensitive fields defined is not possible.

    :param project_id: (required)
    :type project_id: str
    :param create_cwl_with_json_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_with_json_input_analysis: CreateCwlWithJsonInputAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_analysis_with_json_input_serialize(
        project_id=project_id,
        create_cwl_with_json_input_analysis=create_cwl_with_json_input_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create and start an analysis for a CWL pipeline with an input.json.

This endpoint is intended to be used with an input.json and will bypass the input form. The combination of using this endpoint with an input.json for a json-form based pipeline with sensitive fields defined is not possible.

:param project_id: (required) :type project_id: str :param create_cwl_with_json_input_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_with_json_input_analysis: CreateCwlWithJsonInputAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_analysis_with_json_input_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_with_json_input_analysis: Annotated[CreateCwlWithJsonInputAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[AnalysisV4]

Expand source code

@validate_call
def create_cwl_analysis_with_json_input_with_http_info(
    self,
    project_id: StrictStr,
    create_cwl_with_json_input_analysis: Annotated[CreateCwlWithJsonInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisV4]:
    """Create and start an analysis for a CWL pipeline with an input.json.

    This endpoint is intended to be used with an input.json and will bypass the input form. The combination of using this endpoint with an input.json for a json-form based pipeline with sensitive fields defined is not possible.

    :param project_id: (required)
    :type project_id: str
    :param create_cwl_with_json_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_with_json_input_analysis: CreateCwlWithJsonInputAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_analysis_with_json_input_serialize(
        project_id=project_id,
        create_cwl_with_json_input_analysis=create_cwl_with_json_input_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create and start an analysis for a CWL pipeline with an input.json.

This endpoint is intended to be used with an input.json and will bypass the input form. The combination of using this endpoint with an input.json for a json-form based pipeline with sensitive fields defined is not possible.

:param project_id: (required) :type project_id: str :param create_cwl_with_json_input_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_with_json_input_analysis: CreateCwlWithJsonInputAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_analysis_with_json_input_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_with_json_input_analysis: Annotated[CreateCwlWithJsonInputAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_cwl_analysis_with_json_input_without_preload_content(
    self,
    project_id: StrictStr,
    create_cwl_with_json_input_analysis: Annotated[CreateCwlWithJsonInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create and start an analysis for a CWL pipeline with an input.json.

    This endpoint is intended to be used with an input.json and will bypass the input form. The combination of using this endpoint with an input.json for a json-form based pipeline with sensitive fields defined is not possible.

    :param project_id: (required)
    :type project_id: str
    :param create_cwl_with_json_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_with_json_input_analysis: CreateCwlWithJsonInputAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_analysis_with_json_input_serialize(
        project_id=project_id,
        create_cwl_with_json_input_analysis=create_cwl_with_json_input_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create and start an analysis for a CWL pipeline with an input.json.

This endpoint is intended to be used with an input.json and will bypass the input form. The combination of using this endpoint with an input.json for a json-form based pipeline with sensitive fields defined is not possible.

:param project_id: (required) :type project_id: str :param create_cwl_with_json_input_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_with_json_input_analysis: CreateCwlWithJsonInputAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_analysis_with_structured_input(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_with_structured_input_analysis: Annotated[CreateCwlWithStructuredInputAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> AnalysisV4

Expand source code

@validate_call
def create_cwl_analysis_with_structured_input(
    self,
    project_id: StrictStr,
    create_cwl_with_structured_input_analysis: Annotated[CreateCwlWithStructuredInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisV4:
    """Create and start an analysis for a CWL pipeline with a structured input.


    :param project_id: (required)
    :type project_id: str
    :param create_cwl_with_structured_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_with_structured_input_analysis: CreateCwlWithStructuredInputAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_analysis_with_structured_input_serialize(
        project_id=project_id,
        create_cwl_with_structured_input_analysis=create_cwl_with_structured_input_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create and start an analysis for a CWL pipeline with a structured input.

:param project_id: (required) :type project_id: str :param create_cwl_with_structured_input_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_with_structured_input_analysis: CreateCwlWithStructuredInputAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_analysis_with_structured_input_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_with_structured_input_analysis: Annotated[CreateCwlWithStructuredInputAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[AnalysisV4]

Expand source code

@validate_call
def create_cwl_analysis_with_structured_input_with_http_info(
    self,
    project_id: StrictStr,
    create_cwl_with_structured_input_analysis: Annotated[CreateCwlWithStructuredInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisV4]:
    """Create and start an analysis for a CWL pipeline with a structured input.


    :param project_id: (required)
    :type project_id: str
    :param create_cwl_with_structured_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_with_structured_input_analysis: CreateCwlWithStructuredInputAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_analysis_with_structured_input_serialize(
        project_id=project_id,
        create_cwl_with_structured_input_analysis=create_cwl_with_structured_input_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create and start an analysis for a CWL pipeline with a structured input.

:param project_id: (required) :type project_id: str :param create_cwl_with_structured_input_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_with_structured_input_analysis: CreateCwlWithStructuredInputAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_analysis_with_structured_input_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_with_structured_input_analysis: Annotated[CreateCwlWithStructuredInputAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_cwl_analysis_with_structured_input_without_preload_content(
    self,
    project_id: StrictStr,
    create_cwl_with_structured_input_analysis: Annotated[CreateCwlWithStructuredInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create and start an analysis for a CWL pipeline with a structured input.


    :param project_id: (required)
    :type project_id: str
    :param create_cwl_with_structured_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_with_structured_input_analysis: CreateCwlWithStructuredInputAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_analysis_with_structured_input_serialize(
        project_id=project_id,
        create_cwl_with_structured_input_analysis=create_cwl_with_structured_input_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create and start an analysis for a CWL pipeline with a structured input.

:param project_id: (required) :type project_id: str :param create_cwl_with_structured_input_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_with_structured_input_analysis: CreateCwlWithStructuredInputAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_analysis_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_analysis: Annotated[CreateCwlAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_cwl_analysis_without_preload_content(
    self,
    project_id: StrictStr,
    create_cwl_analysis: Annotated[CreateCwlAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Create and start an analysis for a CWL pipeline.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param create_cwl_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_analysis: CreateCwlAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("POST /api/projects/{projectId}/analysis:cwl is deprecated.", DeprecationWarning)

    _param = self._create_cwl_analysis_serialize(
        project_id=project_id,
        create_cwl_analysis=create_cwl_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

(Deprecated) Create and start an analysis for a CWL pipeline.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param create_cwl_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_analysis: CreateCwlAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_json_analysis(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_json_analysis: Annotated[CreateCwlJsonAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> AnalysisV4

Expand source code

@validate_call
def create_cwl_json_analysis(
    self,
    project_id: StrictStr,
    create_cwl_json_analysis: Annotated[CreateCwlJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisV4:
    """Create and start an analysis for a JSON based CWL pipeline.


    :param project_id: (required)
    :type project_id: str
    :param create_cwl_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_json_analysis: CreateCwlJsonAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_json_analysis_serialize(
        project_id=project_id,
        create_cwl_json_analysis=create_cwl_json_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create and start an analysis for a JSON based CWL pipeline.

:param project_id: (required) :type project_id: str :param create_cwl_json_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_json_analysis: CreateCwlJsonAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_json_analysis_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_json_analysis: Annotated[CreateCwlJsonAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[AnalysisV4]

Expand source code

@validate_call
def create_cwl_json_analysis_with_http_info(
    self,
    project_id: StrictStr,
    create_cwl_json_analysis: Annotated[CreateCwlJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisV4]:
    """Create and start an analysis for a JSON based CWL pipeline.


    :param project_id: (required)
    :type project_id: str
    :param create_cwl_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_json_analysis: CreateCwlJsonAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_json_analysis_serialize(
        project_id=project_id,
        create_cwl_json_analysis=create_cwl_json_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create and start an analysis for a JSON based CWL pipeline.

:param project_id: (required) :type project_id: str :param create_cwl_json_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_json_analysis: CreateCwlJsonAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_json_analysis_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_cwl_json_analysis: Annotated[CreateCwlJsonAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_cwl_json_analysis_without_preload_content(
    self,
    project_id: StrictStr,
    create_cwl_json_analysis: Annotated[CreateCwlJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create and start an analysis for a JSON based CWL pipeline.


    :param project_id: (required)
    :type project_id: str
    :param create_cwl_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_cwl_json_analysis: CreateCwlJsonAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_json_analysis_serialize(
        project_id=project_id,
        create_cwl_json_analysis=create_cwl_json_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create and start an analysis for a JSON based CWL pipeline.

:param project_id: (required) :type project_id: str :param create_cwl_json_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_cwl_json_analysis: CreateCwlJsonAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_analysis(self,
project_id: Annotated[str, Strict(strict=True)],
create_nextflow_analysis: Annotated[CreateNextflowAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> AnalysisV4

Expand source code

@validate_call
def create_nextflow_analysis(
    self,
    project_id: StrictStr,
    create_nextflow_analysis: Annotated[CreateNextflowAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisV4:
    """Create and start an analysis for a Nextflow pipeline.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param create_nextflow_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_nextflow_analysis: CreateNextflowAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_analysis_serialize(
        project_id=project_id,
        create_nextflow_analysis=create_nextflow_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create and start an analysis for a Nextflow pipeline.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param create_nextflow_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_nextflow_analysis: CreateNextflowAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_analysis_with_custom_input(self,
project_id: Annotated[str, Strict(strict=True)],
create_nextflow_with_custom_input_analysis: Annotated[CreateNextflowWithCustomInputAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> AnalysisV4

Expand source code

@validate_call
def create_nextflow_analysis_with_custom_input(
    self,
    project_id: StrictStr,
    create_nextflow_with_custom_input_analysis: Annotated[CreateNextflowWithCustomInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisV4:
    """Create and initiate an analysis for a Nextflow pipeline using a custom input, provided in either YAML format or an escaped JSON string.

    This endpoint is intended to be used with a custom input and will bypass the input form. The combination of using this endpoint with a custom input for a json-form based pipeline with sensitive fields defined is not possible.

    :param project_id: (required)
    :type project_id: str
    :param create_nextflow_with_custom_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_nextflow_with_custom_input_analysis: CreateNextflowWithCustomInputAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_analysis_with_custom_input_serialize(
        project_id=project_id,
        create_nextflow_with_custom_input_analysis=create_nextflow_with_custom_input_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create and initiate an analysis for a Nextflow pipeline using a custom input, provided in either YAML format or an escaped JSON string.

This endpoint is intended to be used with a custom input and will bypass the input form. The combination of using this endpoint with a custom input for a json-form based pipeline with sensitive fields defined is not possible.

:param project_id: (required) :type project_id: str :param create_nextflow_with_custom_input_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_nextflow_with_custom_input_analysis: CreateNextflowWithCustomInputAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_analysis_with_custom_input_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_nextflow_with_custom_input_analysis: Annotated[CreateNextflowWithCustomInputAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[AnalysisV4]

Expand source code

@validate_call
def create_nextflow_analysis_with_custom_input_with_http_info(
    self,
    project_id: StrictStr,
    create_nextflow_with_custom_input_analysis: Annotated[CreateNextflowWithCustomInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisV4]:
    """Create and initiate an analysis for a Nextflow pipeline using a custom input, provided in either YAML format or an escaped JSON string.

    This endpoint is intended to be used with a custom input and will bypass the input form. The combination of using this endpoint with a custom input for a json-form based pipeline with sensitive fields defined is not possible.

    :param project_id: (required)
    :type project_id: str
    :param create_nextflow_with_custom_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_nextflow_with_custom_input_analysis: CreateNextflowWithCustomInputAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_analysis_with_custom_input_serialize(
        project_id=project_id,
        create_nextflow_with_custom_input_analysis=create_nextflow_with_custom_input_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create and initiate an analysis for a Nextflow pipeline using a custom input, provided in either YAML format or an escaped JSON string.

This endpoint is intended to be used with a custom input and will bypass the input form. The combination of using this endpoint with a custom input for a json-form based pipeline with sensitive fields defined is not possible.

:param project_id: (required) :type project_id: str :param create_nextflow_with_custom_input_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_nextflow_with_custom_input_analysis: CreateNextflowWithCustomInputAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_analysis_with_custom_input_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_nextflow_with_custom_input_analysis: Annotated[CreateNextflowWithCustomInputAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_nextflow_analysis_with_custom_input_without_preload_content(
    self,
    project_id: StrictStr,
    create_nextflow_with_custom_input_analysis: Annotated[CreateNextflowWithCustomInputAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create and initiate an analysis for a Nextflow pipeline using a custom input, provided in either YAML format or an escaped JSON string.

    This endpoint is intended to be used with a custom input and will bypass the input form. The combination of using this endpoint with a custom input for a json-form based pipeline with sensitive fields defined is not possible.

    :param project_id: (required)
    :type project_id: str
    :param create_nextflow_with_custom_input_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_nextflow_with_custom_input_analysis: CreateNextflowWithCustomInputAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_analysis_with_custom_input_serialize(
        project_id=project_id,
        create_nextflow_with_custom_input_analysis=create_nextflow_with_custom_input_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create and initiate an analysis for a Nextflow pipeline using a custom input, provided in either YAML format or an escaped JSON string.

This endpoint is intended to be used with a custom input and will bypass the input form. The combination of using this endpoint with a custom input for a json-form based pipeline with sensitive fields defined is not possible.

:param project_id: (required) :type project_id: str :param create_nextflow_with_custom_input_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_nextflow_with_custom_input_analysis: CreateNextflowWithCustomInputAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_analysis_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_nextflow_analysis: Annotated[CreateNextflowAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[AnalysisV4]

Expand source code

@validate_call
def create_nextflow_analysis_with_http_info(
    self,
    project_id: StrictStr,
    create_nextflow_analysis: Annotated[CreateNextflowAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisV4]:
    """Create and start an analysis for a Nextflow pipeline.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param create_nextflow_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_nextflow_analysis: CreateNextflowAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_analysis_serialize(
        project_id=project_id,
        create_nextflow_analysis=create_nextflow_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create and start an analysis for a Nextflow pipeline.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param create_nextflow_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_nextflow_analysis: CreateNextflowAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_analysis_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_nextflow_analysis: Annotated[CreateNextflowAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_nextflow_analysis_without_preload_content(
    self,
    project_id: StrictStr,
    create_nextflow_analysis: Annotated[CreateNextflowAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create and start an analysis for a Nextflow pipeline.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param create_nextflow_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_nextflow_analysis: CreateNextflowAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_analysis_serialize(
        project_id=project_id,
        create_nextflow_analysis=create_nextflow_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create and start an analysis for a Nextflow pipeline.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param create_nextflow_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_nextflow_analysis: CreateNextflowAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_json_analysis(self,
project_id: Annotated[str, Strict(strict=True)],
create_nextflow_json_analysis: Annotated[CreateNextflowJsonAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> AnalysisV4

Expand source code

@validate_call
def create_nextflow_json_analysis(
    self,
    project_id: StrictStr,
    create_nextflow_json_analysis: Annotated[CreateNextflowJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisV4:
    """Create and start an analysis for a JSON based Nextflow pipeline.


    :param project_id: (required)
    :type project_id: str
    :param create_nextflow_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_nextflow_json_analysis: CreateNextflowJsonAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_json_analysis_serialize(
        project_id=project_id,
        create_nextflow_json_analysis=create_nextflow_json_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create and start an analysis for a JSON based Nextflow pipeline.

:param project_id: (required) :type project_id: str :param create_nextflow_json_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_nextflow_json_analysis: CreateNextflowJsonAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_json_analysis_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_nextflow_json_analysis: Annotated[CreateNextflowJsonAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[AnalysisV4]

Expand source code

@validate_call
def create_nextflow_json_analysis_with_http_info(
    self,
    project_id: StrictStr,
    create_nextflow_json_analysis: Annotated[CreateNextflowJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisV4]:
    """Create and start an analysis for a JSON based Nextflow pipeline.


    :param project_id: (required)
    :type project_id: str
    :param create_nextflow_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_nextflow_json_analysis: CreateNextflowJsonAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_json_analysis_serialize(
        project_id=project_id,
        create_nextflow_json_analysis=create_nextflow_json_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create and start an analysis for a JSON based Nextflow pipeline.

:param project_id: (required) :type project_id: str :param create_nextflow_json_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_nextflow_json_analysis: CreateNextflowJsonAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_json_analysis_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_nextflow_json_analysis: Annotated[CreateNextflowJsonAnalysis, FieldInfo(annotation=NoneType, required=True, description='The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_nextflow_json_analysis_without_preload_content(
    self,
    project_id: StrictStr,
    create_nextflow_json_analysis: Annotated[CreateNextflowJsonAnalysis, Field(description="The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul>")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create and start an analysis for a JSON based Nextflow pipeline.


    :param project_id: (required)
    :type project_id: str
    :param create_nextflow_json_analysis: The following options can be used for actionOnExist:<br /><ul><li>Overwrite (default): If a file with that name already exists, it is overwritten.</li><li>Rename: If a file with that name already exists, an incremental counter is appended to the file name.</li><li>Skip: If a file with that name already exists, the new file is not saved and the data is discarded.</li></ul> (required)
    :type create_nextflow_json_analysis: CreateNextflowJsonAnalysis
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_json_analysis_serialize(
        project_id=project_id,
        create_nextflow_json_analysis=create_nextflow_json_analysis,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create and start an analysis for a JSON based Nextflow pipeline.

:param project_id: (required) :type project_id: str :param create_nextflow_json_analysis: The following options can be used for actionOnExist:

• Overwrite (default): If a file with that name already exists, it is overwritten.
• Rename: If a file with that name already exists, an incremental counter is appended to the file name.
• Skip: If a file with that name already exists, the new file is not saved and the data is discarded.

(required) :type create_nextflow_json_analysis: CreateNextflowJsonAnalysis :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analyses(self,
project_id: Annotated[str, Strict(strict=True)],
reference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference to filter on.')] = None,
userreference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-reference to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
usertag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-tags to filter on.')] = None,
technicaltag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical-tags to filter on.')] = None,
referencetag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference-data-tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None) ‑> AnalysisPagedListV3

Expand source code

@validate_call
def get_analyses(
    self,
    project_id: StrictStr,
    reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
    userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
    technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
    referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisPagedListV3:
    """(Deprecated) Retrieve the list of analyses.

    This endpoint only returns V3 items. Use the search endpoint to get V4 items.

    :param project_id: (required)
    :type project_id: str
    :param reference: The reference to filter on.
    :type reference: str
    :param userreference: The user-reference to filter on.
    :type userreference: str
    :param status: The status to filter on.
    :type status: str
    :param usertag: The user-tags to filter on.
    :type usertag: str
    :param technicaltag: The technical-tags to filter on.
    :type technicaltag: str
    :param referencetag: The reference-data-tags to filter on.
    :type referencetag: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/analyses is deprecated.", DeprecationWarning)

    _param = self._get_analyses_serialize(
        project_id=project_id,
        reference=reference,
        userreference=userreference,
        status=status,
        usertag=usertag,
        technicaltag=technicaltag,
        referencetag=referencetag,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

(Deprecated) Retrieve the list of analyses.

This endpoint only returns V3 items. Use the search endpoint to get V4 items.

:param project_id: (required) :type project_id: str :param reference: The reference to filter on. :type reference: str :param userreference: The user-reference to filter on. :type userreference: str :param status: The status to filter on. :type status: str :param usertag: The user-tags to filter on. :type usertag: str :param technicaltag: The technical-tags to filter on. :type technicaltag: str :param referencetag: The reference-data-tags to filter on. :type referencetag: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analyses_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
reference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference to filter on.')] = None,
userreference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-reference to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
usertag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-tags to filter on.')] = None,
technicaltag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical-tags to filter on.')] = None,
referencetag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference-data-tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None) ‑> ApiResponse[AnalysisPagedListV3]

Expand source code

@validate_call
def get_analyses_with_http_info(
    self,
    project_id: StrictStr,
    reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
    userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
    technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
    referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisPagedListV3]:
    """(Deprecated) Retrieve the list of analyses.

    This endpoint only returns V3 items. Use the search endpoint to get V4 items.

    :param project_id: (required)
    :type project_id: str
    :param reference: The reference to filter on.
    :type reference: str
    :param userreference: The user-reference to filter on.
    :type userreference: str
    :param status: The status to filter on.
    :type status: str
    :param usertag: The user-tags to filter on.
    :type usertag: str
    :param technicaltag: The technical-tags to filter on.
    :type technicaltag: str
    :param referencetag: The reference-data-tags to filter on.
    :type referencetag: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/analyses is deprecated.", DeprecationWarning)

    _param = self._get_analyses_serialize(
        project_id=project_id,
        reference=reference,
        userreference=userreference,
        status=status,
        usertag=usertag,
        technicaltag=technicaltag,
        referencetag=referencetag,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

(Deprecated) Retrieve the list of analyses.

This endpoint only returns V3 items. Use the search endpoint to get V4 items.

:param project_id: (required) :type project_id: str :param reference: The reference to filter on. :type reference: str :param userreference: The user-reference to filter on. :type userreference: str :param status: The status to filter on. :type status: str :param usertag: The user-tags to filter on. :type usertag: str :param technicaltag: The technical-tags to filter on. :type technicaltag: str :param referencetag: The reference-data-tags to filter on. :type referencetag: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analyses_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
reference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference to filter on.')] = None,
userreference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-reference to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
usertag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-tags to filter on.')] = None,
technicaltag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical-tags to filter on.')] = None,
referencetag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference-data-tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analyses_without_preload_content(
    self,
    project_id: StrictStr,
    reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
    userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
    technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
    referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Retrieve the list of analyses.

    This endpoint only returns V3 items. Use the search endpoint to get V4 items.

    :param project_id: (required)
    :type project_id: str
    :param reference: The reference to filter on.
    :type reference: str
    :param userreference: The user-reference to filter on.
    :type userreference: str
    :param status: The status to filter on.
    :type status: str
    :param usertag: The user-tags to filter on.
    :type usertag: str
    :param technicaltag: The technical-tags to filter on.
    :type technicaltag: str
    :param referencetag: The reference-data-tags to filter on.
    :type referencetag: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/analyses is deprecated.", DeprecationWarning)

    _param = self._get_analyses_serialize(
        project_id=project_id,
        reference=reference,
        userreference=userreference,
        status=status,
        usertag=usertag,
        technicaltag=technicaltag,
        referencetag=referencetag,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

(Deprecated) Retrieve the list of analyses.

This endpoint only returns V3 items. Use the search endpoint to get V4 items.

:param project_id: (required) :type project_id: str :param reference: The reference to filter on. :type reference: str :param userreference: The user-reference to filter on. :type userreference: str :param status: The status to filter on. :type status: str :param usertag: The user-tags to filter on. :type usertag: str :param technicaltag: The technical-tags to filter on. :type technicaltag: str :param referencetag: The reference-data-tags to filter on. :type referencetag: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve')]) ‑> AnalysisV4

Expand source code

@validate_call
def get_analysis(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisV4:
    """Retrieve an analysis.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve an analysis.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_configurations(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the libica.openapi.v3.configuration for')]) ‑> ExecutionConfigurationList

Expand source code

@validate_call
def get_analysis_configurations(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the configuration for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ExecutionConfigurationList:
    """Retrieve the configurations of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the configuration for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_configurations_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ExecutionConfigurationList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the configurations of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the configuration for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_configurations_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the libica.openapi.v3.configuration for')]) ‑> ApiResponse[ExecutionConfigurationList]

Expand source code

@validate_call
def get_analysis_configurations_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the configuration for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ExecutionConfigurationList]:
    """Retrieve the configurations of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the configuration for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_configurations_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ExecutionConfigurationList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the configurations of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the configuration for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_configurations_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the libica.openapi.v3.configuration for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_configurations_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the configuration for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the configurations of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the configuration for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_configurations_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ExecutionConfigurationList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the configurations of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the configuration for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_inputs(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the inputs for')]) ‑> AnalysisInputList

Expand source code

@validate_call
def get_analysis_inputs(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the inputs for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisInputList:
    """Retrieve the inputs of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the inputs for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_inputs_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisInputList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the inputs of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the inputs for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_inputs_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the inputs for')]) ‑> ApiResponse[AnalysisInputList]

Expand source code

@validate_call
def get_analysis_inputs_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the inputs for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisInputList]:
    """Retrieve the inputs of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the inputs for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_inputs_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisInputList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the inputs of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the inputs for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_inputs_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the inputs for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_inputs_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the inputs for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the inputs of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the inputs for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_inputs_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisInputList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the inputs of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the inputs for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_outputs(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the outputs for')]) ‑> AnalysisOutputList

Expand source code

@validate_call
def get_analysis_outputs(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the outputs for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisOutputList:
    """Retrieve the outputs of an analysis (limited to the first 200.000 files per output folder). When trying to retrieve the listed data with an endpoint such as GET /api/data/{dataUrn}, data which has already been deleted will be skipped.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the outputs for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_outputs_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisOutputList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the outputs of an analysis (limited to the first 200.000 files per output folder). When trying to retrieve the listed data with an endpoint such as GET /api/data/{dataUrn}, data which has already been deleted will be skipped.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the outputs for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_outputs_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the outputs for')]) ‑> ApiResponse[AnalysisOutputList]

Expand source code

@validate_call
def get_analysis_outputs_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the outputs for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisOutputList]:
    """Retrieve the outputs of an analysis (limited to the first 200.000 files per output folder). When trying to retrieve the listed data with an endpoint such as GET /api/data/{dataUrn}, data which has already been deleted will be skipped.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the outputs for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_outputs_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisOutputList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the outputs of an analysis (limited to the first 200.000 files per output folder). When trying to retrieve the listed data with an endpoint such as GET /api/data/{dataUrn}, data which has already been deleted will be skipped.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the outputs for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_outputs_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the outputs for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_outputs_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the outputs for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the outputs of an analysis (limited to the first 200.000 files per output folder). When trying to retrieve the listed data with an endpoint such as GET /api/data/{dataUrn}, data which has already been deleted will be skipped.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the outputs for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_outputs_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisOutputList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the outputs of an analysis (limited to the first 200.000 files per output folder). When trying to retrieve the listed data with an endpoint such as GET /api/data/{dataUrn}, data which has already been deleted will be skipped.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the outputs for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_reports(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the reports for')]) ‑> AnalysisReportEntryList

Expand source code

@validate_call
def get_analysis_reports(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the reports for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisReportEntryList:
    """Retrieve the report configs and associated reports.

    Retrieves the reports which match the report config defined in a pipeline.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the reports for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_reports_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisReportEntryList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the report configs and associated reports.

Retrieves the reports which match the report config defined in a pipeline.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the reports for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_reports_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the reports for')]) ‑> ApiResponse[AnalysisReportEntryList]

Expand source code

@validate_call
def get_analysis_reports_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the reports for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisReportEntryList]:
    """Retrieve the report configs and associated reports.

    Retrieves the reports which match the report config defined in a pipeline.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the reports for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_reports_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisReportEntryList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the report configs and associated reports.

Retrieves the reports which match the report config defined in a pipeline.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the reports for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_reports_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the reports for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_reports_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the reports for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the report configs and associated reports.

    Retrieves the reports which match the report config defined in a pipeline.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the reports for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_reports_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisReportEntryList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the report configs and associated reports.

Retrieves the reports which match the report config defined in a pipeline.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the reports for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_steps(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the individual steps for')]) ‑> AnalysisStepList

Expand source code

@validate_call
def get_analysis_steps(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the individual steps for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisStepList:
    """Retrieve the individual steps of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the individual steps for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_steps_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisStepList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the individual steps of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the individual steps for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_steps_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the individual steps for')]) ‑> ApiResponse[AnalysisStepList]

Expand source code

@validate_call
def get_analysis_steps_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the individual steps for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisStepList]:
    """Retrieve the individual steps of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the individual steps for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_steps_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisStepList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the individual steps of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the individual steps for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_steps_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the individual steps for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_steps_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the individual steps for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the individual steps of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the individual steps for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_steps_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisStepList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the individual steps of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the individual steps for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_usage_details(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the usage details for')]) ‑> AnalysisUsageDetails

Expand source code

@validate_call
def get_analysis_usage_details(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the usage details for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisUsageDetails:
    """Retrieve the analysis usage details.

    The usage details can be retrieved once the analysis has completed with status SUCCEEDED or FAILED. It may take several minutes for the information to become available. A 404 status indicates that the system is busy processing the information.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the usage details for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_usage_details_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisUsageDetails",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the analysis usage details.

The usage details can be retrieved once the analysis has completed with status SUCCEEDED or FAILED. It may take several minutes for the information to become available. A 404 status indicates that the system is busy processing the information.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the usage details for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_usage_details_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the usage details for')]) ‑> ApiResponse[AnalysisUsageDetails]

Expand source code

@validate_call
def get_analysis_usage_details_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the usage details for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisUsageDetails]:
    """Retrieve the analysis usage details.

    The usage details can be retrieved once the analysis has completed with status SUCCEEDED or FAILED. It may take several minutes for the information to become available. A 404 status indicates that the system is busy processing the information.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the usage details for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_usage_details_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisUsageDetails",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the analysis usage details.

The usage details can be retrieved once the analysis has completed with status SUCCEEDED or FAILED. It may take several minutes for the information to become available. A 404 status indicates that the system is busy processing the information.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the usage details for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_usage_details_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the usage details for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_usage_details_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the usage details for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the analysis usage details.

    The usage details can be retrieved once the analysis has completed with status SUCCEEDED or FAILED. It may take several minutes for the information to become available. A 404 status indicates that the system is busy processing the information.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the usage details for (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_usage_details_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisUsageDetails",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the analysis usage details.

The usage details can be retrieved once the analysis has completed with status SUCCEEDED or FAILED. It may take several minutes for the information to become available. A 404 status indicates that the system is busy processing the information.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the usage details for (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve')]) ‑> ApiResponse[AnalysisV4]

Expand source code

@validate_call
def get_analysis_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisV4]:
    """Retrieve an analysis.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve an analysis.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve an analysis.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve an analysis.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_cwl_input_json(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the CWL analysis for which to retrieve the input json')]) ‑> CwlAnalysisInputJson

Expand source code

@validate_call
def get_cwl_input_json(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the input json")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> CwlAnalysisInputJson:
    """Retrieve the input json of a CWL analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the CWL analysis for which to retrieve the input json (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_cwl_input_json_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CwlAnalysisInputJson",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the input json of a CWL analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the CWL analysis for which to retrieve the input json (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_cwl_input_json_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the CWL analysis for which to retrieve the input json')]) ‑> ApiResponse[CwlAnalysisInputJson]

Expand source code

@validate_call
def get_cwl_input_json_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the input json")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[CwlAnalysisInputJson]:
    """Retrieve the input json of a CWL analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the CWL analysis for which to retrieve the input json (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_cwl_input_json_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CwlAnalysisInputJson",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the input json of a CWL analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the CWL analysis for which to retrieve the input json (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_cwl_input_json_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the CWL analysis for which to retrieve the input json')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_cwl_input_json_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the input json")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the input json of a CWL analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the CWL analysis for which to retrieve the input json (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_cwl_input_json_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CwlAnalysisInputJson",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the input json of a CWL analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the CWL analysis for which to retrieve the input json (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_cwl_output_json(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the CWL analysis for which to retrieve the output json')]) ‑> CwlAnalysisOutputJson

Expand source code

@validate_call
def get_cwl_output_json(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the output json")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> CwlAnalysisOutputJson:
    """Retrieve the output json of a CWL analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the CWL analysis for which to retrieve the output json (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_cwl_output_json_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CwlAnalysisOutputJson",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the output json of a CWL analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the CWL analysis for which to retrieve the output json (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_cwl_output_json_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the CWL analysis for which to retrieve the output json')]) ‑> ApiResponse[CwlAnalysisOutputJson]

Expand source code

@validate_call
def get_cwl_output_json_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the output json")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[CwlAnalysisOutputJson]:
    """Retrieve the output json of a CWL analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the CWL analysis for which to retrieve the output json (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_cwl_output_json_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CwlAnalysisOutputJson",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the output json of a CWL analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the CWL analysis for which to retrieve the output json (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_cwl_output_json_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the CWL analysis for which to retrieve the output json')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_cwl_output_json_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the CWL analysis for which to retrieve the output json")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the output json of a CWL analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the CWL analysis for which to retrieve the output json (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_cwl_output_json_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CwlAnalysisOutputJson",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the output json of a CWL analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the CWL analysis for which to retrieve the output json (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_analysis_input_form_values(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the input form values from')]) ‑> InputFormFieldList

Expand source code

@validate_call
def get_project_analysis_input_form_values(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the input form values from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> InputFormFieldList:
    """Retrieve the values from an input form.

    Retrieve the values from an input form of a JSON based pipeline used to start an analysis.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the input form values from (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_analysis_input_form_values_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InputFormFieldList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the values from an input form.

Retrieve the values from an input form of a JSON based pipeline used to start an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the input form values from (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_analysis_input_form_values_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the input form values from')]) ‑> ApiResponse[InputFormFieldList]

Expand source code

@validate_call
def get_project_analysis_input_form_values_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the input form values from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[InputFormFieldList]:
    """Retrieve the values from an input form.

    Retrieve the values from an input form of a JSON based pipeline used to start an analysis.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the input form values from (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_analysis_input_form_values_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InputFormFieldList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the values from an input form.

Retrieve the values from an input form of a JSON based pipeline used to start an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the input form values from (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_analysis_input_form_values_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis to retrieve the input form values from')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_analysis_input_form_values_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis to retrieve the input form values from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the values from an input form.

    Retrieve the values from an input form of a JSON based pipeline used to start an analysis.

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis to retrieve the input form values from (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_analysis_input_form_values_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InputFormFieldList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the values from an input form.

Retrieve the values from an input form of a JSON based pipeline used to start an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis to retrieve the input form values from (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_raw_analysis_output(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis for which to retrieve the raw output')]) ‑> AnalysisRawOutput

Expand source code

@validate_call
def get_raw_analysis_output(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis for which to retrieve the raw output")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisRawOutput:
    """(Deprecated) Retrieve the raw output of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis for which to retrieve the raw output (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/analyses/{analysisId}/rawOutput is deprecated.", DeprecationWarning)

    _param = self._get_raw_analysis_output_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisRawOutput",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

(Deprecated) Retrieve the raw output of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis for which to retrieve the raw output (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_raw_analysis_output_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis for which to retrieve the raw output')]) ‑> ApiResponse[AnalysisRawOutput]

Expand source code

@validate_call
def get_raw_analysis_output_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis for which to retrieve the raw output")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisRawOutput]:
    """(Deprecated) Retrieve the raw output of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis for which to retrieve the raw output (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/analyses/{analysisId}/rawOutput is deprecated.", DeprecationWarning)

    _param = self._get_raw_analysis_output_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisRawOutput",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

(Deprecated) Retrieve the raw output of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis for which to retrieve the raw output (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_raw_analysis_output_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis for which to retrieve the raw output')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_raw_analysis_output_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: Annotated[StrictStr, Field(description="The ID of the analysis for which to retrieve the raw output")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Retrieve the raw output of an analysis.


    :param project_id: (required)
    :type project_id: str
    :param analysis_id: The ID of the analysis for which to retrieve the raw output (required)
    :type analysis_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/analyses/{analysisId}/rawOutput is deprecated.", DeprecationWarning)

    _param = self._get_raw_analysis_output_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisRawOutput",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

(Deprecated) Retrieve the raw output of an analysis.

:param project_id: (required) :type project_id: str :param analysis_id: The ID of the analysis for which to retrieve the raw output (required) :type analysis_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_analyses(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> AnalysisPagedListV4

Expand source code

@validate_call
def search_analyses(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisPagedListV4:
    """Search analyses.


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_analyses_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Search analyses.

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_analyses_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> ApiResponse[AnalysisPagedListV4]

Expand source code

@validate_call
def search_analyses_with_http_info(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisPagedListV4]:
    """Search analyses.


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_analyses_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Search analyses.

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_analyses_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def search_analyses_without_preload_content(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Search analyses.


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_analyses_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Search analyses.

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_analysis(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True)],
analysis_v4: AnalysisV4,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> AnalysisV4

Expand source code

@validate_call
def update_analysis(
    self,
    project_id: StrictStr,
    analysis_id: StrictStr,
    analysis_v4: AnalysisV4,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisV4:
    """Update an analysis.

    # Attributes which can be updated:    - tags # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: (required)
    :type analysis_id: str
    :param analysis_v4: (required)
    :type analysis_v4: AnalysisV4
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_analysis_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        analysis_v4=analysis_v4,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update an analysis.

Attributes which can be updated: - tags # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param analysis_id: (required) :type analysis_id: str :param analysis_v4: (required) :type analysis_v4: AnalysisV4 :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_analysis_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True)],
analysis_v4: AnalysisV4,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[AnalysisV4]

Expand source code

@validate_call
def update_analysis_with_http_info(
    self,
    project_id: StrictStr,
    analysis_id: StrictStr,
    analysis_v4: AnalysisV4,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisV4]:
    """Update an analysis.

    # Attributes which can be updated:    - tags # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: (required)
    :type analysis_id: str
    :param analysis_v4: (required)
    :type analysis_v4: AnalysisV4
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_analysis_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        analysis_v4=analysis_v4,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update an analysis.

Attributes which can be updated: - tags # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param analysis_id: (required) :type analysis_id: str :param analysis_v4: (required) :type analysis_v4: AnalysisV4 :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_analysis_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
analysis_id: Annotated[str, Strict(strict=True)],
analysis_v4: AnalysisV4,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_analysis_without_preload_content(
    self,
    project_id: StrictStr,
    analysis_id: StrictStr,
    analysis_v4: AnalysisV4,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update an analysis.

    # Attributes which can be updated:    - tags # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4]  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param analysis_id: (required)
    :type analysis_id: str
    :param analysis_v4: (required)
    :type analysis_v4: AnalysisV4
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_analysis_serialize(
        project_id=project_id,
        analysis_id=analysis_id,
        analysis_v4=analysis_v4,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update an analysis.

Attributes which can be updated: - tags # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param analysis_id: (required) :type analysis_id: str :param analysis_v4: (required) :type analysis_v4: AnalysisV4 :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectAnalysisCreationBatchApi (api_client=None)

Expand source code

class ProjectAnalysisCreationBatchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_analysis_creation_batch(
        self,
        project_id: StrictStr,
        create_analysis_creation_batch: CreateAnalysisCreationBatch,
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisCreationBatch:
        """Create and start multiple analyses in batch.


        :param project_id: (required)
        :type project_id: str
        :param create_analysis_creation_batch: (required)
        :type create_analysis_creation_batch: CreateAnalysisCreationBatch
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_analysis_creation_batch_serialize(
            project_id=project_id,
            create_analysis_creation_batch=create_analysis_creation_batch,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_analysis_creation_batch_with_http_info(
        self,
        project_id: StrictStr,
        create_analysis_creation_batch: CreateAnalysisCreationBatch,
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisCreationBatch]:
        """Create and start multiple analyses in batch.


        :param project_id: (required)
        :type project_id: str
        :param create_analysis_creation_batch: (required)
        :type create_analysis_creation_batch: CreateAnalysisCreationBatch
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_analysis_creation_batch_serialize(
            project_id=project_id,
            create_analysis_creation_batch=create_analysis_creation_batch,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_analysis_creation_batch_without_preload_content(
        self,
        project_id: StrictStr,
        create_analysis_creation_batch: CreateAnalysisCreationBatch,
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create and start multiple analyses in batch.


        :param project_id: (required)
        :type project_id: str
        :param create_analysis_creation_batch: (required)
        :type create_analysis_creation_batch: CreateAnalysisCreationBatch
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_analysis_creation_batch_serialize(
            project_id=project_id,
            create_analysis_creation_batch=create_analysis_creation_batch,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "AnalysisCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_analysis_creation_batch_serialize(
        self,
        project_id,
        create_analysis_creation_batch,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_analysis_creation_batch is not None:
            _body_params = create_analysis_creation_batch


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/analysisCreationBatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis_creation_batch(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisCreationBatch:
        """Retrieve a analysis creation batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the analysis creation batch (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_creation_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_creation_batch_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisCreationBatch]:
        """Retrieve a analysis creation batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the analysis creation batch (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_creation_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_creation_batch_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a analysis creation batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the analysis creation batch (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_creation_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_creation_batch_serialize(
        self,
        project_id,
        batch_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analysisCreationBatch/{batchId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis_creation_batch_item(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
        item_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch item")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisCreationBatchItemV4:
        """Retrieve a analysis creation batch item.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the analysis creation batch (required)
        :type batch_id: str
        :param item_id: The ID of the analysis creation batch item (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_creation_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisCreationBatchItemV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_creation_batch_item_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
        item_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch item")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisCreationBatchItemV4]:
        """Retrieve a analysis creation batch item.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the analysis creation batch (required)
        :type batch_id: str
        :param item_id: The ID of the analysis creation batch item (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_creation_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisCreationBatchItemV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_creation_batch_item_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
        item_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch item")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a analysis creation batch item.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the analysis creation batch (required)
        :type batch_id: str
        :param item_id: The ID of the analysis creation batch item (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_creation_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisCreationBatchItemV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_creation_batch_item_serialize(
        self,
        project_id,
        batch_id,
        item_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        if item_id is not None:
            _path_params['itemId'] = item_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analysisCreationBatch/{batchId}/items/{itemId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_analysis_creation_batch_items(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisCreationBatchItemPagedListV4:
        """Retrieve a list of analysis creation batch items.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4] ## Item field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the analysis creation batch (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_creation_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisCreationBatchItemPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_analysis_creation_batch_items_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisCreationBatchItemPagedListV4]:
        """Retrieve a list of analysis creation batch items.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4] ## Item field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the analysis creation batch (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_creation_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisCreationBatchItemPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_analysis_creation_batch_items_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of analysis creation batch items.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4] ## Item field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the analysis creation batch (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_analysis_creation_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisCreationBatchItemPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_analysis_creation_batch_items_serialize(
        self,
        project_id,
        batch_id,
        status,
        page_offset,
        page_token,
        page_size,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analysisCreationBatch/{batchId}/items',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_analysis_creation_batch(self,
project_id: Annotated[str, Strict(strict=True)],
create_analysis_creation_batch: CreateAnalysisCreationBatch,
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> AnalysisCreationBatch

Expand source code

@validate_call
def create_analysis_creation_batch(
    self,
    project_id: StrictStr,
    create_analysis_creation_batch: CreateAnalysisCreationBatch,
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisCreationBatch:
    """Create and start multiple analyses in batch.


    :param project_id: (required)
    :type project_id: str
    :param create_analysis_creation_batch: (required)
    :type create_analysis_creation_batch: CreateAnalysisCreationBatch
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_analysis_creation_batch_serialize(
        project_id=project_id,
        create_analysis_creation_batch=create_analysis_creation_batch,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create and start multiple analyses in batch.

:param project_id: (required) :type project_id: str :param create_analysis_creation_batch: (required) :type create_analysis_creation_batch: CreateAnalysisCreationBatch :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_analysis_creation_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_analysis_creation_batch: CreateAnalysisCreationBatch,
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[AnalysisCreationBatch]

Expand source code

@validate_call
def create_analysis_creation_batch_with_http_info(
    self,
    project_id: StrictStr,
    create_analysis_creation_batch: CreateAnalysisCreationBatch,
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisCreationBatch]:
    """Create and start multiple analyses in batch.


    :param project_id: (required)
    :type project_id: str
    :param create_analysis_creation_batch: (required)
    :type create_analysis_creation_batch: CreateAnalysisCreationBatch
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_analysis_creation_batch_serialize(
        project_id=project_id,
        create_analysis_creation_batch=create_analysis_creation_batch,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create and start multiple analyses in batch.

:param project_id: (required) :type project_id: str :param create_analysis_creation_batch: (required) :type create_analysis_creation_batch: CreateAnalysisCreationBatch :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_analysis_creation_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_analysis_creation_batch: CreateAnalysisCreationBatch,
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_analysis_creation_batch_without_preload_content(
    self,
    project_id: StrictStr,
    create_analysis_creation_batch: CreateAnalysisCreationBatch,
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create and start multiple analyses in batch.


    :param project_id: (required)
    :type project_id: str
    :param create_analysis_creation_batch: (required)
    :type create_analysis_creation_batch: CreateAnalysisCreationBatch
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_analysis_creation_batch_serialize(
        project_id=project_id,
        create_analysis_creation_batch=create_analysis_creation_batch,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "AnalysisCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create and start multiple analyses in batch.

:param project_id: (required) :type project_id: str :param create_analysis_creation_batch: (required) :type create_analysis_creation_batch: CreateAnalysisCreationBatch :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_creation_batch(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch')]) ‑> AnalysisCreationBatch

Expand source code

@validate_call
def get_analysis_creation_batch(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisCreationBatch:
    """Retrieve a analysis creation batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the analysis creation batch (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_creation_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a analysis creation batch.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the analysis creation batch (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_creation_batch_item(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch')],
item_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch item')]) ‑> AnalysisCreationBatchItemV4

Expand source code

@validate_call
def get_analysis_creation_batch_item(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
    item_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch item")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisCreationBatchItemV4:
    """Retrieve a analysis creation batch item.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the analysis creation batch (required)
    :type batch_id: str
    :param item_id: The ID of the analysis creation batch item (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_creation_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisCreationBatchItemV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a analysis creation batch item.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Field 'createdAnalysis' changes: * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the analysis creation batch (required) :type batch_id: str :param item_id: The ID of the analysis creation batch item (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_creation_batch_item_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch')],
item_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch item')]) ‑> ApiResponse[AnalysisCreationBatchItemV4]

Expand source code

@validate_call
def get_analysis_creation_batch_item_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
    item_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch item")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisCreationBatchItemV4]:
    """Retrieve a analysis creation batch item.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the analysis creation batch (required)
    :type batch_id: str
    :param item_id: The ID of the analysis creation batch item (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_creation_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisCreationBatchItemV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a analysis creation batch item.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Field 'createdAnalysis' changes: * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the analysis creation batch (required) :type batch_id: str :param item_id: The ID of the analysis creation batch item (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_creation_batch_item_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch')],
item_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch item')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_creation_batch_item_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
    item_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch item")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a analysis creation batch item.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the analysis creation batch (required)
    :type batch_id: str
    :param item_id: The ID of the analysis creation batch item (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_creation_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisCreationBatchItemV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a analysis creation batch item.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Field 'createdAnalysis' changes: * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the analysis creation batch (required) :type batch_id: str :param item_id: The ID of the analysis creation batch item (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_creation_batch_items(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch')],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> AnalysisCreationBatchItemPagedListV4

Expand source code

@validate_call
def get_analysis_creation_batch_items(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisCreationBatchItemPagedListV4:
    """Retrieve a list of analysis creation batch items.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4] ## Item field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the analysis creation batch (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_creation_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisCreationBatchItemPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of analysis creation batch items.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] ## Item field 'createdAnalysis' changes: * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the analysis creation batch (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_creation_batch_items_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch')],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ApiResponse[AnalysisCreationBatchItemPagedListV4]

Expand source code

@validate_call
def get_analysis_creation_batch_items_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisCreationBatchItemPagedListV4]:
    """Retrieve a list of analysis creation batch items.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4] ## Item field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the analysis creation batch (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_creation_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisCreationBatchItemPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of analysis creation batch items.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] ## Item field 'createdAnalysis' changes: * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the analysis creation batch (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_creation_batch_items_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch')],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_creation_batch_items_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of analysis creation batch items.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3]  * Initial version ## [V4] ## Item field 'createdAnalysis' changes:  * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING'].  * Field analysisPriority changed from enum to String.  * The owner and tenant are now represented by Identifier objects. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the analysis creation batch (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_creation_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisCreationBatchItemPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of analysis creation batch items.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] * Initial version ## [V4] ## Item field 'createdAnalysis' changes: * Field type 'status' changed from enum to String. New statuses have been added: ['QUEUED', 'INITIALIZING', 'PREPARING_INPUTS', 'GENERATING_OUTPUTS', 'ABORTING']. * Field analysisPriority changed from enum to String. * The owner and tenant are now represented by Identifier objects.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the analysis creation batch (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_creation_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch')]) ‑> ApiResponse[AnalysisCreationBatch]

Expand source code

@validate_call
def get_analysis_creation_batch_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisCreationBatch]:
    """Retrieve a analysis creation batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the analysis creation batch (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_creation_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a analysis creation batch.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the analysis creation batch (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_analysis_creation_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the analysis creation batch')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_analysis_creation_batch_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the analysis creation batch")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a analysis creation batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the analysis creation batch (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_analysis_creation_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a analysis creation batch.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the analysis creation batch (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectAnalysisStorageApi (api_client=None)

Expand source code

class ProjectAnalysisStorageApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_project_analysis_storage_options(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisStorageListV4:
        """Retrieve the list of project analysis storage options.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_analysis_storage_options_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisStorageListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_analysis_storage_options_with_http_info(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisStorageListV4]:
        """Retrieve the list of project analysis storage options.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_analysis_storage_options_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisStorageListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_analysis_storage_options_without_preload_content(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the list of project analysis storage options.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_analysis_storage_options_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisStorageListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_analysis_storage_options_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/analysisStorages',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_project_analysis_storage_options(self, project_id: Annotated[str, Strict(strict=True)]) ‑> AnalysisStorageListV4

Expand source code

@validate_call
def get_project_analysis_storage_options(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisStorageListV4:
    """Retrieve the list of project analysis storage options.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_analysis_storage_options_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisStorageListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the list of project analysis storage options.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_analysis_storage_options_with_http_info(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[AnalysisStorageListV4]

Expand source code

@validate_call
def get_project_analysis_storage_options_with_http_info(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisStorageListV4]:
    """Retrieve the list of project analysis storage options.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_analysis_storage_options_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisStorageListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the list of project analysis storage options.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_analysis_storage_options_without_preload_content(self, project_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_analysis_storage_options_without_preload_content(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the list of project analysis storage options.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_analysis_storage_options_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisStorageListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the list of project analysis storage options.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectApi (api_client=None)

Expand source code

class ProjectApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def change_project_owner(
        self,
        project_id: StrictStr,
        change_project_owner: ChangeProjectOwner,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Change the project owner.


        :param project_id: (required)
        :type project_id: str
        :param change_project_owner: (required)
        :type change_project_owner: ChangeProjectOwner
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._change_project_owner_serialize(
            project_id=project_id,
            change_project_owner=change_project_owner,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def change_project_owner_with_http_info(
        self,
        project_id: StrictStr,
        change_project_owner: ChangeProjectOwner,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Change the project owner.


        :param project_id: (required)
        :type project_id: str
        :param change_project_owner: (required)
        :type change_project_owner: ChangeProjectOwner
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._change_project_owner_serialize(
            project_id=project_id,
            change_project_owner=change_project_owner,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def change_project_owner_without_preload_content(
        self,
        project_id: StrictStr,
        change_project_owner: ChangeProjectOwner,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Change the project owner.


        :param project_id: (required)
        :type project_id: str
        :param change_project_owner: (required)
        :type change_project_owner: ChangeProjectOwner
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._change_project_owner_serialize(
            project_id=project_id,
            change_project_owner=change_project_owner,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _change_project_owner_serialize(
        self,
        project_id,
        change_project_owner,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if change_project_owner is not None:
            _body_params = change_project_owner


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}:changeOwner',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_project(
        self,
        create_project: CreateProject,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Project:
        """Create a new project.


        :param create_project: (required)
        :type create_project: CreateProject
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_serialize(
            create_project=create_project,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "Project",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_project_with_http_info(
        self,
        create_project: CreateProject,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Project]:
        """Create a new project.


        :param create_project: (required)
        :type create_project: CreateProject
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_serialize(
            create_project=create_project,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "Project",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_project_without_preload_content(
        self,
        create_project: CreateProject,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a new project.


        :param create_project: (required)
        :type create_project: CreateProject
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_serialize(
            create_project=create_project,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "Project",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_project_serialize(
        self,
        create_project,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_project is not None:
            _body_params = create_project


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Project:
        """Retrieve a project.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Project",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_with_http_info(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Project]:
        """Retrieve a project.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Project",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_without_preload_content(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Project",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_bundle(
        self,
        project_id: StrictStr,
        bundle_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectBundle:
        """Retrieve a project bundle.


        :param project_id: (required)
        :type project_id: str
        :param bundle_id: (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_bundle_serialize(
            project_id=project_id,
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_bundle_with_http_info(
        self,
        project_id: StrictStr,
        bundle_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectBundle]:
        """Retrieve a project bundle.


        :param project_id: (required)
        :type project_id: str
        :param bundle_id: (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_bundle_serialize(
            project_id=project_id,
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_bundle_without_preload_content(
        self,
        project_id: StrictStr,
        bundle_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project bundle.


        :param project_id: (required)
        :type project_id: str
        :param bundle_id: (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_bundle_serialize(
            project_id=project_id,
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_bundle_serialize(
        self,
        project_id,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/bundles/{bundleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_bundles(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectBundleList:
        """Retrieve project bundles.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_bundles_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBundleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_bundles_with_http_info(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectBundleList]:
        """Retrieve project bundles.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_bundles_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBundleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_bundles_without_preload_content(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve project bundles.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_bundles_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBundleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_bundles_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/bundles',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_projects(
        self,
        search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
        user_tags: Annotated[Optional[List[StrictStr]], Field(description="User tags to filter on")] = None,
        technical_tags: Annotated[Optional[List[StrictStr]], Field(description="Technical tags to filter on")] = None,
        include_hidden_projects: Annotated[Optional[StrictBool], Field(description="Include hidden projects.")] = None,
        region: Annotated[Optional[StrictStr], Field(description="The ID of the region to filter on.")] = None,
        workgroups: Annotated[Optional[List[StrictStr]], Field(description="Workgroup IDs to filter on")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPagedList:
        """Retrieve a list of projects.


        :param search: Search
        :type search: str
        :param user_tags: User tags to filter on
        :type user_tags: List[str]
        :param technical_tags: Technical tags to filter on
        :type technical_tags: List[str]
        :param include_hidden_projects: Include hidden projects.
        :type include_hidden_projects: bool
        :param region: The ID of the region to filter on.
        :type region: str
        :param workgroups: Workgroup IDs to filter on
        :type workgroups: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_projects_serialize(
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            include_hidden_projects=include_hidden_projects,
            region=region,
            workgroups=workgroups,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_projects_with_http_info(
        self,
        search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
        user_tags: Annotated[Optional[List[StrictStr]], Field(description="User tags to filter on")] = None,
        technical_tags: Annotated[Optional[List[StrictStr]], Field(description="Technical tags to filter on")] = None,
        include_hidden_projects: Annotated[Optional[StrictBool], Field(description="Include hidden projects.")] = None,
        region: Annotated[Optional[StrictStr], Field(description="The ID of the region to filter on.")] = None,
        workgroups: Annotated[Optional[List[StrictStr]], Field(description="Workgroup IDs to filter on")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPagedList]:
        """Retrieve a list of projects.


        :param search: Search
        :type search: str
        :param user_tags: User tags to filter on
        :type user_tags: List[str]
        :param technical_tags: Technical tags to filter on
        :type technical_tags: List[str]
        :param include_hidden_projects: Include hidden projects.
        :type include_hidden_projects: bool
        :param region: The ID of the region to filter on.
        :type region: str
        :param workgroups: Workgroup IDs to filter on
        :type workgroups: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_projects_serialize(
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            include_hidden_projects=include_hidden_projects,
            region=region,
            workgroups=workgroups,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_projects_without_preload_content(
        self,
        search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
        user_tags: Annotated[Optional[List[StrictStr]], Field(description="User tags to filter on")] = None,
        technical_tags: Annotated[Optional[List[StrictStr]], Field(description="Technical tags to filter on")] = None,
        include_hidden_projects: Annotated[Optional[StrictBool], Field(description="Include hidden projects.")] = None,
        region: Annotated[Optional[StrictStr], Field(description="The ID of the region to filter on.")] = None,
        workgroups: Annotated[Optional[List[StrictStr]], Field(description="Workgroup IDs to filter on")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of projects.


        :param search: Search
        :type search: str
        :param user_tags: User tags to filter on
        :type user_tags: List[str]
        :param technical_tags: Technical tags to filter on
        :type technical_tags: List[str]
        :param include_hidden_projects: Include hidden projects.
        :type include_hidden_projects: bool
        :param region: The ID of the region to filter on.
        :type region: str
        :param workgroups: Workgroup IDs to filter on
        :type workgroups: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_projects_serialize(
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            include_hidden_projects=include_hidden_projects,
            region=region,
            workgroups=workgroups,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_projects_serialize(
        self,
        search,
        user_tags,
        technical_tags,
        include_hidden_projects,
        region,
        workgroups,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'userTags': 'multi',
            'technicalTags': 'multi',
            'workgroups': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if search is not None:
            
            _query_params.append(('search', search))
            
        if user_tags is not None:
            
            _query_params.append(('userTags', user_tags))
            
        if technical_tags is not None:
            
            _query_params.append(('technicalTags', technical_tags))
            
        if include_hidden_projects is not None:
            
            _query_params.append(('includeHiddenProjects', include_hidden_projects))
            
        if region is not None:
            
            _query_params.append(('region', region))
            
        if workgroups is not None:
            
            _query_params.append(('workgroups', workgroups))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def hide_project(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Hide a project.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._hide_project_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def hide_project_with_http_info(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Hide a project.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._hide_project_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def hide_project_without_preload_content(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Hide a project.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._hide_project_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _hide_project_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}:hide',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def link_project_bundle(
        self,
        project_id: StrictStr,
        bundle_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectBundle:
        """Link a bundle to a project.


        :param project_id: (required)
        :type project_id: str
        :param bundle_id: (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_project_bundle_serialize(
            project_id=project_id,
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def link_project_bundle_with_http_info(
        self,
        project_id: StrictStr,
        bundle_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectBundle]:
        """Link a bundle to a project.


        :param project_id: (required)
        :type project_id: str
        :param bundle_id: (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_project_bundle_serialize(
            project_id=project_id,
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def link_project_bundle_without_preload_content(
        self,
        project_id: StrictStr,
        bundle_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Link a bundle to a project.


        :param project_id: (required)
        :type project_id: str
        :param bundle_id: (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_project_bundle_serialize(
            project_id=project_id,
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBundle",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _link_project_bundle_serialize(
        self,
        project_id,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/bundles/{bundleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unlink_project_bundle(
        self,
        project_id: StrictStr,
        bundle_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Unlink a bundle from a project.


        :param project_id: (required)
        :type project_id: str
        :param bundle_id: (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_project_bundle_serialize(
            project_id=project_id,
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unlink_project_bundle_with_http_info(
        self,
        project_id: StrictStr,
        bundle_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Unlink a bundle from a project.


        :param project_id: (required)
        :type project_id: str
        :param bundle_id: (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_project_bundle_serialize(
            project_id=project_id,
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unlink_project_bundle_without_preload_content(
        self,
        project_id: StrictStr,
        bundle_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Unlink a bundle from a project.


        :param project_id: (required)
        :type project_id: str
        :param bundle_id: (required)
        :type bundle_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_project_bundle_serialize(
            project_id=project_id,
            bundle_id=bundle_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unlink_project_bundle_serialize(
        self,
        project_id,
        bundle_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if bundle_id is not None:
            _path_params['bundleId'] = bundle_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/projects/{projectId}/bundles/{bundleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_project(
        self,
        project_id: StrictStr,
        project: Project,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Project:
        """Update a project.

        Fields which can be updated: - shortDescription - projectInformation - billingMode - dataSharingEnabled - tags - storageBundle - metaDataModel - analysisPriority

        :param project_id: (required)
        :type project_id: str
        :param project: (required)
        :type project: Project
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_serialize(
            project_id=project_id,
            project=project,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Project",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_project_with_http_info(
        self,
        project_id: StrictStr,
        project: Project,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Project]:
        """Update a project.

        Fields which can be updated: - shortDescription - projectInformation - billingMode - dataSharingEnabled - tags - storageBundle - metaDataModel - analysisPriority

        :param project_id: (required)
        :type project_id: str
        :param project: (required)
        :type project: Project
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_serialize(
            project_id=project_id,
            project=project,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Project",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_project_without_preload_content(
        self,
        project_id: StrictStr,
        project: Project,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a project.

        Fields which can be updated: - shortDescription - projectInformation - billingMode - dataSharingEnabled - tags - storageBundle - metaDataModel - analysisPriority

        :param project_id: (required)
        :type project_id: str
        :param project: (required)
        :type project: Project
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_serialize(
            project_id=project_id,
            project=project,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Project",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_project_serialize(
        self,
        project_id,
        project,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if project is not None:
            _body_params = project


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def change_project_owner(self,
project_id: Annotated[str, Strict(strict=True)],
change_project_owner: ChangeProjectOwner) ‑> None

Expand source code

@validate_call
def change_project_owner(
    self,
    project_id: StrictStr,
    change_project_owner: ChangeProjectOwner,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Change the project owner.


    :param project_id: (required)
    :type project_id: str
    :param change_project_owner: (required)
    :type change_project_owner: ChangeProjectOwner
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._change_project_owner_serialize(
        project_id=project_id,
        change_project_owner=change_project_owner,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Change the project owner.

:param project_id: (required) :type project_id: str :param change_project_owner: (required) :type change_project_owner: ChangeProjectOwner :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def change_project_owner_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
change_project_owner: ChangeProjectOwner) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def change_project_owner_with_http_info(
    self,
    project_id: StrictStr,
    change_project_owner: ChangeProjectOwner,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Change the project owner.


    :param project_id: (required)
    :type project_id: str
    :param change_project_owner: (required)
    :type change_project_owner: ChangeProjectOwner
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._change_project_owner_serialize(
        project_id=project_id,
        change_project_owner=change_project_owner,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Change the project owner.

:param project_id: (required) :type project_id: str :param change_project_owner: (required) :type change_project_owner: ChangeProjectOwner :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def change_project_owner_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
change_project_owner: ChangeProjectOwner) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def change_project_owner_without_preload_content(
    self,
    project_id: StrictStr,
    change_project_owner: ChangeProjectOwner,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Change the project owner.


    :param project_id: (required)
    :type project_id: str
    :param change_project_owner: (required)
    :type change_project_owner: ChangeProjectOwner
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._change_project_owner_serialize(
        project_id=project_id,
        change_project_owner=change_project_owner,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Change the project owner.

:param project_id: (required) :type project_id: str :param change_project_owner: (required) :type change_project_owner: ChangeProjectOwner :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project(self,
create_project: CreateProject) ‑> Project

Expand source code

@validate_call
def create_project(
    self,
    create_project: CreateProject,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Project:
    """Create a new project.


    :param create_project: (required)
    :type create_project: CreateProject
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_serialize(
        create_project=create_project,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "Project",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a new project.

:param create_project: (required) :type create_project: CreateProject :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_with_http_info(self,
create_project: CreateProject) ‑> ApiResponse[Project]

Expand source code

@validate_call
def create_project_with_http_info(
    self,
    create_project: CreateProject,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Project]:
    """Create a new project.


    :param create_project: (required)
    :type create_project: CreateProject
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_serialize(
        create_project=create_project,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "Project",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a new project.

:param create_project: (required) :type create_project: CreateProject :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_without_preload_content(self,
create_project: CreateProject) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_project_without_preload_content(
    self,
    create_project: CreateProject,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a new project.


    :param create_project: (required)
    :type create_project: CreateProject
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_serialize(
        create_project=create_project,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "Project",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a new project.

:param create_project: (required) :type create_project: CreateProject :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project(self, project_id: Annotated[str, Strict(strict=True)]) ‑> Project

Expand source code

@validate_call
def get_project(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Project:
    """Retrieve a project.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Project",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_bundle(self,
project_id: Annotated[str, Strict(strict=True)],
bundle_id: Annotated[str, Strict(strict=True)]) ‑> ProjectBundle

Expand source code

@validate_call
def get_project_bundle(
    self,
    project_id: StrictStr,
    bundle_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectBundle:
    """Retrieve a project bundle.


    :param project_id: (required)
    :type project_id: str
    :param bundle_id: (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_bundle_serialize(
        project_id=project_id,
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project bundle.

:param project_id: (required) :type project_id: str :param bundle_id: (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_bundle_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
bundle_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectBundle]

Expand source code

@validate_call
def get_project_bundle_with_http_info(
    self,
    project_id: StrictStr,
    bundle_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectBundle]:
    """Retrieve a project bundle.


    :param project_id: (required)
    :type project_id: str
    :param bundle_id: (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_bundle_serialize(
        project_id=project_id,
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project bundle.

:param project_id: (required) :type project_id: str :param bundle_id: (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_bundle_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
bundle_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_bundle_without_preload_content(
    self,
    project_id: StrictStr,
    bundle_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project bundle.


    :param project_id: (required)
    :type project_id: str
    :param bundle_id: (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_bundle_serialize(
        project_id=project_id,
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project bundle.

:param project_id: (required) :type project_id: str :param bundle_id: (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_bundles(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ProjectBundleList

Expand source code

@validate_call
def get_project_bundles(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectBundleList:
    """Retrieve project bundles.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_bundles_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBundleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve project bundles.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_bundles_with_http_info(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectBundleList]

Expand source code

@validate_call
def get_project_bundles_with_http_info(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectBundleList]:
    """Retrieve project bundles.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_bundles_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBundleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve project bundles.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_bundles_without_preload_content(self, project_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_bundles_without_preload_content(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve project bundles.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_bundles_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBundleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve project bundles.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_with_http_info(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[Project]

Expand source code

@validate_call
def get_project_with_http_info(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Project]:
    """Retrieve a project.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Project",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_without_preload_content(self, project_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_without_preload_content(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Project",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_projects(self,
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search')] = None,
user_tags: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='User tags to filter on')] = None,
technical_tags: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='Technical tags to filter on')] = None,
include_hidden_projects: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include hidden projects.')] = None,
region: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The ID of the region to filter on.')] = None,
workgroups: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='Workgroup IDs to filter on')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription - information')] = None) ‑> ProjectPagedList

Expand source code

@validate_call
def get_projects(
    self,
    search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
    user_tags: Annotated[Optional[List[StrictStr]], Field(description="User tags to filter on")] = None,
    technical_tags: Annotated[Optional[List[StrictStr]], Field(description="Technical tags to filter on")] = None,
    include_hidden_projects: Annotated[Optional[StrictBool], Field(description="Include hidden projects.")] = None,
    region: Annotated[Optional[StrictStr], Field(description="The ID of the region to filter on.")] = None,
    workgroups: Annotated[Optional[List[StrictStr]], Field(description="Workgroup IDs to filter on")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPagedList:
    """Retrieve a list of projects.


    :param search: Search
    :type search: str
    :param user_tags: User tags to filter on
    :type user_tags: List[str]
    :param technical_tags: Technical tags to filter on
    :type technical_tags: List[str]
    :param include_hidden_projects: Include hidden projects.
    :type include_hidden_projects: bool
    :param region: The ID of the region to filter on.
    :type region: str
    :param workgroups: Workgroup IDs to filter on
    :type workgroups: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_projects_serialize(
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        include_hidden_projects=include_hidden_projects,
        region=region,
        workgroups=workgroups,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of projects.

:param search: Search :type search: str :param user_tags: User tags to filter on :type user_tags: List[str] :param technical_tags: Technical tags to filter on :type technical_tags: List[str] :param include_hidden_projects: Include hidden projects. :type include_hidden_projects: bool :param region: The ID of the region to filter on. :type region: str :param workgroups: Workgroup IDs to filter on :type workgroups: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription - information :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_projects_with_http_info(self,
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search')] = None,
user_tags: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='User tags to filter on')] = None,
technical_tags: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='Technical tags to filter on')] = None,
include_hidden_projects: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include hidden projects.')] = None,
region: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The ID of the region to filter on.')] = None,
workgroups: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='Workgroup IDs to filter on')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription - information')] = None) ‑> ApiResponse[ProjectPagedList]

Expand source code

@validate_call
def get_projects_with_http_info(
    self,
    search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
    user_tags: Annotated[Optional[List[StrictStr]], Field(description="User tags to filter on")] = None,
    technical_tags: Annotated[Optional[List[StrictStr]], Field(description="Technical tags to filter on")] = None,
    include_hidden_projects: Annotated[Optional[StrictBool], Field(description="Include hidden projects.")] = None,
    region: Annotated[Optional[StrictStr], Field(description="The ID of the region to filter on.")] = None,
    workgroups: Annotated[Optional[List[StrictStr]], Field(description="Workgroup IDs to filter on")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPagedList]:
    """Retrieve a list of projects.


    :param search: Search
    :type search: str
    :param user_tags: User tags to filter on
    :type user_tags: List[str]
    :param technical_tags: Technical tags to filter on
    :type technical_tags: List[str]
    :param include_hidden_projects: Include hidden projects.
    :type include_hidden_projects: bool
    :param region: The ID of the region to filter on.
    :type region: str
    :param workgroups: Workgroup IDs to filter on
    :type workgroups: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_projects_serialize(
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        include_hidden_projects=include_hidden_projects,
        region=region,
        workgroups=workgroups,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of projects.

:param search: Search :type search: str :param user_tags: User tags to filter on :type user_tags: List[str] :param technical_tags: Technical tags to filter on :type technical_tags: List[str] :param include_hidden_projects: Include hidden projects. :type include_hidden_projects: bool :param region: The ID of the region to filter on. :type region: str :param workgroups: Workgroup IDs to filter on :type workgroups: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription - information :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_projects_without_preload_content(self,
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Search')] = None,
user_tags: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='User tags to filter on')] = None,
technical_tags: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='Technical tags to filter on')] = None,
include_hidden_projects: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Include hidden projects.')] = None,
region: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The ID of the region to filter on.')] = None,
workgroups: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='Workgroup IDs to filter on')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription - information')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_projects_without_preload_content(
    self,
    search: Annotated[Optional[StrictStr], Field(description="Search")] = None,
    user_tags: Annotated[Optional[List[StrictStr]], Field(description="User tags to filter on")] = None,
    technical_tags: Annotated[Optional[List[StrictStr]], Field(description="Technical tags to filter on")] = None,
    include_hidden_projects: Annotated[Optional[StrictBool], Field(description="Include hidden projects.")] = None,
    region: Annotated[Optional[StrictStr], Field(description="The ID of the region to filter on.")] = None,
    workgroups: Annotated[Optional[List[StrictStr]], Field(description="Workgroup IDs to filter on")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of projects.


    :param search: Search
    :type search: str
    :param user_tags: User tags to filter on
    :type user_tags: List[str]
    :param technical_tags: Technical tags to filter on
    :type technical_tags: List[str]
    :param include_hidden_projects: Include hidden projects.
    :type include_hidden_projects: bool
    :param region: The ID of the region to filter on.
    :type region: str
    :param workgroups: Workgroup IDs to filter on
    :type workgroups: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - name - shortDescription - information
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_projects_serialize(
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        include_hidden_projects=include_hidden_projects,
        region=region,
        workgroups=workgroups,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of projects.

:param search: Search :type search: str :param user_tags: User tags to filter on :type user_tags: List[str] :param technical_tags: Technical tags to filter on :type technical_tags: List[str] :param include_hidden_projects: Include hidden projects. :type include_hidden_projects: bool :param region: The ID of the region to filter on. :type region: str :param workgroups: Workgroup IDs to filter on :type workgroups: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - name - shortDescription - information :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def hide_project(self, project_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def hide_project(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Hide a project.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._hide_project_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Hide a project.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def hide_project_with_http_info(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def hide_project_with_http_info(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Hide a project.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._hide_project_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Hide a project.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def hide_project_without_preload_content(self, project_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def hide_project_without_preload_content(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Hide a project.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._hide_project_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Hide a project.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_project_bundle(self,
project_id: Annotated[str, Strict(strict=True)],
bundle_id: Annotated[str, Strict(strict=True)]) ‑> ProjectBundle

Expand source code

@validate_call
def link_project_bundle(
    self,
    project_id: StrictStr,
    bundle_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectBundle:
    """Link a bundle to a project.


    :param project_id: (required)
    :type project_id: str
    :param bundle_id: (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_project_bundle_serialize(
        project_id=project_id,
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Link a bundle to a project.

:param project_id: (required) :type project_id: str :param bundle_id: (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_project_bundle_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
bundle_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectBundle]

Expand source code

@validate_call
def link_project_bundle_with_http_info(
    self,
    project_id: StrictStr,
    bundle_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectBundle]:
    """Link a bundle to a project.


    :param project_id: (required)
    :type project_id: str
    :param bundle_id: (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_project_bundle_serialize(
        project_id=project_id,
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Link a bundle to a project.

:param project_id: (required) :type project_id: str :param bundle_id: (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_project_bundle_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
bundle_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def link_project_bundle_without_preload_content(
    self,
    project_id: StrictStr,
    bundle_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Link a bundle to a project.


    :param project_id: (required)
    :type project_id: str
    :param bundle_id: (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_project_bundle_serialize(
        project_id=project_id,
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBundle",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Link a bundle to a project.

:param project_id: (required) :type project_id: str :param bundle_id: (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_project_bundle(self,
project_id: Annotated[str, Strict(strict=True)],
bundle_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def unlink_project_bundle(
    self,
    project_id: StrictStr,
    bundle_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Unlink a bundle from a project.


    :param project_id: (required)
    :type project_id: str
    :param bundle_id: (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_project_bundle_serialize(
        project_id=project_id,
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Unlink a bundle from a project.

:param project_id: (required) :type project_id: str :param bundle_id: (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_project_bundle_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
bundle_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unlink_project_bundle_with_http_info(
    self,
    project_id: StrictStr,
    bundle_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Unlink a bundle from a project.


    :param project_id: (required)
    :type project_id: str
    :param bundle_id: (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_project_bundle_serialize(
        project_id=project_id,
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Unlink a bundle from a project.

:param project_id: (required) :type project_id: str :param bundle_id: (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_project_bundle_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
bundle_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unlink_project_bundle_without_preload_content(
    self,
    project_id: StrictStr,
    bundle_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Unlink a bundle from a project.


    :param project_id: (required)
    :type project_id: str
    :param bundle_id: (required)
    :type bundle_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_project_bundle_serialize(
        project_id=project_id,
        bundle_id=bundle_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Unlink a bundle from a project.

:param project_id: (required) :type project_id: str :param bundle_id: (required) :type bundle_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project(self,
project_id: Annotated[str, Strict(strict=True)],
project: Project,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> Project

Expand source code

@validate_call
def update_project(
    self,
    project_id: StrictStr,
    project: Project,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Project:
    """Update a project.

    Fields which can be updated: - shortDescription - projectInformation - billingMode - dataSharingEnabled - tags - storageBundle - metaDataModel - analysisPriority

    :param project_id: (required)
    :type project_id: str
    :param project: (required)
    :type project: Project
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_serialize(
        project_id=project_id,
        project=project,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Project",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update a project.

Fields which can be updated: - shortDescription - projectInformation - billingMode - dataSharingEnabled - tags - storageBundle - metaDataModel - analysisPriority

:param project_id: (required) :type project_id: str :param project: (required) :type project: Project :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
project: Project,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[Project]

Expand source code

@validate_call
def update_project_with_http_info(
    self,
    project_id: StrictStr,
    project: Project,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Project]:
    """Update a project.

    Fields which can be updated: - shortDescription - projectInformation - billingMode - dataSharingEnabled - tags - storageBundle - metaDataModel - analysisPriority

    :param project_id: (required)
    :type project_id: str
    :param project: (required)
    :type project: Project
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_serialize(
        project_id=project_id,
        project=project,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Project",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update a project.

Fields which can be updated: - shortDescription - projectInformation - billingMode - dataSharingEnabled - tags - storageBundle - metaDataModel - analysisPriority

:param project_id: (required) :type project_id: str :param project: (required) :type project: Project :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
project: Project,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_project_without_preload_content(
    self,
    project_id: StrictStr,
    project: Project,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update a project.

    Fields which can be updated: - shortDescription - projectInformation - billingMode - dataSharingEnabled - tags - storageBundle - metaDataModel - analysisPriority

    :param project_id: (required)
    :type project_id: str
    :param project: (required)
    :type project: Project
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_serialize(
        project_id=project_id,
        project=project,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Project",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update a project.

Fields which can be updated: - shortDescription - projectInformation - billingMode - dataSharingEnabled - tags - storageBundle - metaDataModel - analysisPriority

:param project_id: (required) :type project_id: str :param project: (required) :type project: Project :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectBaseApi (api_client=None)

Expand source code

class ProjectBaseApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_base_connection_details(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BaseConnection:
        """Creates the connection details to snowflake instance.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_base_connection_details_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BaseConnection",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_base_connection_details_with_http_info(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BaseConnection]:
        """Creates the connection details to snowflake instance.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_base_connection_details_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BaseConnection",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_base_connection_details_without_preload_content(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Creates the connection details to snowflake instance.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_base_connection_details_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BaseConnection",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_base_connection_details_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/base:connectionDetails',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_base_job(
        self,
        project_id: StrictStr,
        base_job_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BaseJob:
        """Retrieve a base job.


        :param project_id: (required)
        :type project_id: str
        :param base_job_id: (required)
        :type base_job_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_base_job_serialize(
            project_id=project_id,
            base_job_id=base_job_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BaseJob",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_base_job_with_http_info(
        self,
        project_id: StrictStr,
        base_job_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BaseJob]:
        """Retrieve a base job.


        :param project_id: (required)
        :type project_id: str
        :param base_job_id: (required)
        :type base_job_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_base_job_serialize(
            project_id=project_id,
            base_job_id=base_job_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BaseJob",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_base_job_without_preload_content(
        self,
        project_id: StrictStr,
        base_job_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a base job.


        :param project_id: (required)
        :type project_id: str
        :param base_job_id: (required)
        :type base_job_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_base_job_serialize(
            project_id=project_id,
            base_job_id=base_job_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BaseJob",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_base_job_serialize(
        self,
        project_id,
        base_job_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if base_job_id is not None:
            _path_params['baseJobId'] = base_job_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/base/jobs/{baseJobId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_base_jobs(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BaseJobList:
        """Retrieve a list of base jobs


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_base_jobs_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BaseJobList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_base_jobs_with_http_info(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BaseJobList]:
        """Retrieve a list of base jobs


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_base_jobs_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BaseJobList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_base_jobs_without_preload_content(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of base jobs


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_base_jobs_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "BaseJobList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_base_jobs_serialize(
        self,
        project_id,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/base/jobs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_base_tables(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectBaseTableList:
        """Retrieve a list of base tables.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_base_tables_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBaseTableList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_base_tables_with_http_info(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectBaseTableList]:
        """Retrieve a list of base tables.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_base_tables_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBaseTableList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_base_tables_without_preload_content(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of base tables.


        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_base_tables_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectBaseTableList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_base_tables_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/base/tables',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def load_data(
        self,
        project_id: StrictStr,
        table_id: StrictStr,
        load_data_in_base_request: Annotated[LoadDataInBaseRequest, Field(description="Load data request")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> BaseJob:
        """Load data in a base table.

        Load data in the specified table

        :param project_id: (required)
        :type project_id: str
        :param table_id: (required)
        :type table_id: str
        :param load_data_in_base_request: Load data request (required)
        :type load_data_in_base_request: LoadDataInBaseRequest
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._load_data_serialize(
            project_id=project_id,
            table_id=table_id,
            load_data_in_base_request=load_data_in_base_request,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "BaseJob",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def load_data_with_http_info(
        self,
        project_id: StrictStr,
        table_id: StrictStr,
        load_data_in_base_request: Annotated[LoadDataInBaseRequest, Field(description="Load data request")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[BaseJob]:
        """Load data in a base table.

        Load data in the specified table

        :param project_id: (required)
        :type project_id: str
        :param table_id: (required)
        :type table_id: str
        :param load_data_in_base_request: Load data request (required)
        :type load_data_in_base_request: LoadDataInBaseRequest
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._load_data_serialize(
            project_id=project_id,
            table_id=table_id,
            load_data_in_base_request=load_data_in_base_request,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "BaseJob",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def load_data_without_preload_content(
        self,
        project_id: StrictStr,
        table_id: StrictStr,
        load_data_in_base_request: Annotated[LoadDataInBaseRequest, Field(description="Load data request")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Load data in a base table.

        Load data in the specified table

        :param project_id: (required)
        :type project_id: str
        :param table_id: (required)
        :type table_id: str
        :param load_data_in_base_request: Load data request (required)
        :type load_data_in_base_request: LoadDataInBaseRequest
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._load_data_serialize(
            project_id=project_id,
            table_id=table_id,
            load_data_in_base_request=load_data_in_base_request,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "BaseJob",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _load_data_serialize(
        self,
        project_id,
        table_id,
        load_data_in_base_request,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if table_id is not None:
            _path_params['tableId'] = table_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if load_data_in_base_request is not None:
            _body_params = load_data_in_base_request


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/base/tables/{tableId}:loadData',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_base_connection_details(self, project_id: Annotated[str, Strict(strict=True)]) ‑> BaseConnection

Expand source code

@validate_call
def create_base_connection_details(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BaseConnection:
    """Creates the connection details to snowflake instance.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_base_connection_details_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BaseConnection",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Creates the connection details to snowflake instance.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_base_connection_details_with_http_info(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[BaseConnection]

Expand source code

@validate_call
def create_base_connection_details_with_http_info(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BaseConnection]:
    """Creates the connection details to snowflake instance.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_base_connection_details_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BaseConnection",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Creates the connection details to snowflake instance.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_base_connection_details_without_preload_content(self, project_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_base_connection_details_without_preload_content(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Creates the connection details to snowflake instance.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_base_connection_details_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BaseConnection",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Creates the connection details to snowflake instance.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_base_job(self,
project_id: Annotated[str, Strict(strict=True)],
base_job_id: Annotated[str, Strict(strict=True)]) ‑> BaseJob

Expand source code

@validate_call
def get_base_job(
    self,
    project_id: StrictStr,
    base_job_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BaseJob:
    """Retrieve a base job.


    :param project_id: (required)
    :type project_id: str
    :param base_job_id: (required)
    :type base_job_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_base_job_serialize(
        project_id=project_id,
        base_job_id=base_job_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BaseJob",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a base job.

:param project_id: (required) :type project_id: str :param base_job_id: (required) :type base_job_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_base_job_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
base_job_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[BaseJob]

Expand source code

@validate_call
def get_base_job_with_http_info(
    self,
    project_id: StrictStr,
    base_job_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BaseJob]:
    """Retrieve a base job.


    :param project_id: (required)
    :type project_id: str
    :param base_job_id: (required)
    :type base_job_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_base_job_serialize(
        project_id=project_id,
        base_job_id=base_job_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BaseJob",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a base job.

:param project_id: (required) :type project_id: str :param base_job_id: (required) :type base_job_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_base_job_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
base_job_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_base_job_without_preload_content(
    self,
    project_id: StrictStr,
    base_job_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a base job.


    :param project_id: (required)
    :type project_id: str
    :param base_job_id: (required)
    :type base_job_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_base_job_serialize(
        project_id=project_id,
        base_job_id=base_job_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BaseJob",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a base job.

:param project_id: (required) :type project_id: str :param base_job_id: (required) :type base_job_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_base_jobs(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - description - type')] = None) ‑> BaseJobList

Expand source code

@validate_call
def get_base_jobs(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BaseJobList:
    """Retrieve a list of base jobs


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_base_jobs_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BaseJobList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of base jobs

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - description - type :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_base_jobs_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - description - type')] = None) ‑> ApiResponse[BaseJobList]

Expand source code

@validate_call
def get_base_jobs_with_http_info(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BaseJobList]:
    """Retrieve a list of base jobs


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_base_jobs_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BaseJobList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of base jobs

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - description - type :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_base_jobs_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - description - type')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_base_jobs_without_preload_content(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of base jobs


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - description - type
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_base_jobs_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "BaseJobList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of base jobs

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - description - type :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_base_tables(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ProjectBaseTableList

Expand source code

@validate_call
def get_base_tables(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectBaseTableList:
    """Retrieve a list of base tables.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_base_tables_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBaseTableList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of base tables.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_base_tables_with_http_info(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectBaseTableList]

Expand source code

@validate_call
def get_base_tables_with_http_info(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectBaseTableList]:
    """Retrieve a list of base tables.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_base_tables_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBaseTableList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of base tables.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_base_tables_without_preload_content(self, project_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_base_tables_without_preload_content(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of base tables.


    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_base_tables_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectBaseTableList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of base tables.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def load_data(self,
project_id: Annotated[str, Strict(strict=True)],
table_id: Annotated[str, Strict(strict=True)],
load_data_in_base_request: Annotated[LoadDataInBaseRequest, FieldInfo(annotation=NoneType, required=True, description='Load data request')]) ‑> BaseJob

Expand source code

@validate_call
def load_data(
    self,
    project_id: StrictStr,
    table_id: StrictStr,
    load_data_in_base_request: Annotated[LoadDataInBaseRequest, Field(description="Load data request")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> BaseJob:
    """Load data in a base table.

    Load data in the specified table

    :param project_id: (required)
    :type project_id: str
    :param table_id: (required)
    :type table_id: str
    :param load_data_in_base_request: Load data request (required)
    :type load_data_in_base_request: LoadDataInBaseRequest
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._load_data_serialize(
        project_id=project_id,
        table_id=table_id,
        load_data_in_base_request=load_data_in_base_request,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "BaseJob",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Load data in a base table.

Load data in the specified table

:param project_id: (required) :type project_id: str :param table_id: (required) :type table_id: str :param load_data_in_base_request: Load data request (required) :type load_data_in_base_request: LoadDataInBaseRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def load_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
table_id: Annotated[str, Strict(strict=True)],
load_data_in_base_request: Annotated[LoadDataInBaseRequest, FieldInfo(annotation=NoneType, required=True, description='Load data request')]) ‑> ApiResponse[BaseJob]

Expand source code

@validate_call
def load_data_with_http_info(
    self,
    project_id: StrictStr,
    table_id: StrictStr,
    load_data_in_base_request: Annotated[LoadDataInBaseRequest, Field(description="Load data request")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[BaseJob]:
    """Load data in a base table.

    Load data in the specified table

    :param project_id: (required)
    :type project_id: str
    :param table_id: (required)
    :type table_id: str
    :param load_data_in_base_request: Load data request (required)
    :type load_data_in_base_request: LoadDataInBaseRequest
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._load_data_serialize(
        project_id=project_id,
        table_id=table_id,
        load_data_in_base_request=load_data_in_base_request,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "BaseJob",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Load data in a base table.

Load data in the specified table

:param project_id: (required) :type project_id: str :param table_id: (required) :type table_id: str :param load_data_in_base_request: Load data request (required) :type load_data_in_base_request: LoadDataInBaseRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def load_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
table_id: Annotated[str, Strict(strict=True)],
load_data_in_base_request: Annotated[LoadDataInBaseRequest, FieldInfo(annotation=NoneType, required=True, description='Load data request')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def load_data_without_preload_content(
    self,
    project_id: StrictStr,
    table_id: StrictStr,
    load_data_in_base_request: Annotated[LoadDataInBaseRequest, Field(description="Load data request")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Load data in a base table.

    Load data in the specified table

    :param project_id: (required)
    :type project_id: str
    :param table_id: (required)
    :type table_id: str
    :param load_data_in_base_request: Load data request (required)
    :type load_data_in_base_request: LoadDataInBaseRequest
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._load_data_serialize(
        project_id=project_id,
        table_id=table_id,
        load_data_in_base_request=load_data_in_base_request,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "BaseJob",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Load data in a base table.

Load data in the specified table

:param project_id: (required) :type project_id: str :param table_id: (required) :type table_id: str :param load_data_in_base_request: Load data request (required) :type load_data_in_base_request: LoadDataInBaseRequest :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectBaseTable (**data: Any)

Expand source code

class ProjectBaseTable(BaseModel):
    """
    ProjectBaseTable
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the table which should be used in writing queries")
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=4000)]] = Field(default=None, description="The description of the table")
    type: StrictStr = Field(description="The type of the table")
    status: StrictStr = Field(description="The status of the table")
    number_of_records: Optional[StrictInt] = Field(default=None, description="The number of record in the table", alias="numberOfRecords")
    data_size: Optional[StrictInt] = Field(default=None, description="The amount of Data contained in this table in bytes", alias="dataSize")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "description", "type", "status", "numberOfRecords", "dataSize"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['TABLE', 'VIEW']):
            raise ValueError("must be one of enum values ('TABLE', 'VIEW')")
        return value

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['AVAILABLE', 'DELETED', 'PENDING']):
            raise ValueError("must be one of enum values ('AVAILABLE', 'DELETED', 'PENDING')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectBaseTable from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if number_of_records (nullable) is None
        # and model_fields_set contains the field
        if self.number_of_records is None and "number_of_records" in self.model_fields_set:
            _dict['numberOfRecords'] = None

        # set to None if data_size (nullable) is None
        # and model_fields_set contains the field
        if self.data_size is None and "data_size" in self.model_fields_set:
            _dict['dataSize'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectBaseTable from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "description": obj.get("description"),
            "type": obj.get("type"),
            "status": obj.get("status"),
            "numberOfRecords": obj.get("numberOfRecords"),
            "dataSize": obj.get("dataSize")
        })
        return _obj

ProjectBaseTable

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_size : int | None

The type of the None singleton.

var description : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var number_of_records : int | None

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var status : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectBaseTable from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectBaseTable from a JSON string

def status_validate_enum(value)

Validates the enum

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if number_of_records (nullable) is None
    # and model_fields_set contains the field
    if self.number_of_records is None and "number_of_records" in self.model_fields_set:
        _dict['numberOfRecords'] = None

    # set to None if data_size (nullable) is None
    # and model_fields_set contains the field
    if self.data_size is None and "data_size" in self.model_fields_set:
        _dict['dataSize'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectBaseTableList (**data: Any)

Expand source code

class ProjectBaseTableList(BaseModel):
    """
    ProjectBaseTableList
    """ # noqa: E501
    items: List[Optional[ProjectBaseTable]]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectBaseTableList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectBaseTableList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectBaseTable.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ProjectBaseTableList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectBaseTable | None]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectBaseTableList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectBaseTableList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectBundle (**data: Any)

Expand source code

class ProjectBundle(BaseModel):
    """
    ProjectBundle
    """ # noqa: E501
    bundle: Optional[Bundle]
    project_id: StrictStr = Field(alias="projectId")
    application: Optional[ApplicationV4] = None
    __properties: ClassVar[List[str]] = ["bundle", "projectId", "application"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectBundle from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of bundle
        if self.bundle:
            _dict['bundle'] = self.bundle.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # set to None if bundle (nullable) is None
        # and model_fields_set contains the field
        if self.bundle is None and "bundle" in self.model_fields_set:
            _dict['bundle'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectBundle from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "bundle": Bundle.from_dict(obj["bundle"]) if obj.get("bundle") is not None else None,
            "projectId": obj.get("projectId"),
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None
        })
        return _obj

ProjectBundle

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var application : ApplicationV4 | None

The type of the None singleton.

var bundle : Bundle | None

The type of the None singleton.

var model_config

The type of the None singleton.

var project_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectBundle from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectBundle from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of bundle
    if self.bundle:
        _dict['bundle'] = self.bundle.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # set to None if bundle (nullable) is None
    # and model_fields_set contains the field
    if self.bundle is None and "bundle" in self.model_fields_set:
        _dict['bundle'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectBundleList (**data: Any)

Expand source code

class ProjectBundleList(BaseModel):
    """
    ProjectBundleList
    """ # noqa: E501
    items: List[ProjectBundle]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectBundleList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectBundleList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectBundle.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ProjectBundleList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectBundle]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectBundleList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectBundleList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectCustomEventsApi (api_client=None)

Expand source code

class ProjectCustomEventsApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_custom_event(
        self,
        project_id: StrictStr,
        create_custom_event: CreateCustomEvent,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Create a new custom event.

        Warning: this endpoint allows to create custom events with a code larger than 20 characters (max 50), but the endpoint for creating a custom notification subscription (POST /api/projects/{projectId}/customNotificationSubscriptions) only accepts event codes up to 20 characters.

        :param project_id: (required)
        :type project_id: str
        :param create_custom_event: (required)
        :type create_custom_event: CreateCustomEvent
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_custom_event_serialize(
            project_id=project_id,
            create_custom_event=create_custom_event,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_custom_event_with_http_info(
        self,
        project_id: StrictStr,
        create_custom_event: CreateCustomEvent,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Create a new custom event.

        Warning: this endpoint allows to create custom events with a code larger than 20 characters (max 50), but the endpoint for creating a custom notification subscription (POST /api/projects/{projectId}/customNotificationSubscriptions) only accepts event codes up to 20 characters.

        :param project_id: (required)
        :type project_id: str
        :param create_custom_event: (required)
        :type create_custom_event: CreateCustomEvent
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_custom_event_serialize(
            project_id=project_id,
            create_custom_event=create_custom_event,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_custom_event_without_preload_content(
        self,
        project_id: StrictStr,
        create_custom_event: CreateCustomEvent,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a new custom event.

        Warning: this endpoint allows to create custom events with a code larger than 20 characters (max 50), but the endpoint for creating a custom notification subscription (POST /api/projects/{projectId}/customNotificationSubscriptions) only accepts event codes up to 20 characters.

        :param project_id: (required)
        :type project_id: str
        :param create_custom_event: (required)
        :type create_custom_event: CreateCustomEvent
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_custom_event_serialize(
            project_id=project_id,
            create_custom_event=create_custom_event,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_custom_event_serialize(
        self,
        project_id,
        create_custom_event,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_custom_event is not None:
            _body_params = create_custom_event


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/customEvents',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_custom_event(self,
project_id: Annotated[str, Strict(strict=True)],
create_custom_event: CreateCustomEvent) ‑> None

Expand source code

@validate_call
def create_custom_event(
    self,
    project_id: StrictStr,
    create_custom_event: CreateCustomEvent,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Create a new custom event.

    Warning: this endpoint allows to create custom events with a code larger than 20 characters (max 50), but the endpoint for creating a custom notification subscription (POST /api/projects/{projectId}/customNotificationSubscriptions) only accepts event codes up to 20 characters.

    :param project_id: (required)
    :type project_id: str
    :param create_custom_event: (required)
    :type create_custom_event: CreateCustomEvent
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_custom_event_serialize(
        project_id=project_id,
        create_custom_event=create_custom_event,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a new custom event.

Warning: this endpoint allows to create custom events with a code larger than 20 characters (max 50), but the endpoint for creating a custom notification subscription (POST /api/projects/{projectId}/customNotificationSubscriptions) only accepts event codes up to 20 characters.

:param project_id: (required) :type project_id: str :param create_custom_event: (required) :type create_custom_event: CreateCustomEvent :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_custom_event_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_custom_event: CreateCustomEvent) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def create_custom_event_with_http_info(
    self,
    project_id: StrictStr,
    create_custom_event: CreateCustomEvent,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Create a new custom event.

    Warning: this endpoint allows to create custom events with a code larger than 20 characters (max 50), but the endpoint for creating a custom notification subscription (POST /api/projects/{projectId}/customNotificationSubscriptions) only accepts event codes up to 20 characters.

    :param project_id: (required)
    :type project_id: str
    :param create_custom_event: (required)
    :type create_custom_event: CreateCustomEvent
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_custom_event_serialize(
        project_id=project_id,
        create_custom_event=create_custom_event,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a new custom event.

Warning: this endpoint allows to create custom events with a code larger than 20 characters (max 50), but the endpoint for creating a custom notification subscription (POST /api/projects/{projectId}/customNotificationSubscriptions) only accepts event codes up to 20 characters.

:param project_id: (required) :type project_id: str :param create_custom_event: (required) :type create_custom_event: CreateCustomEvent :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_custom_event_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_custom_event: CreateCustomEvent) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_custom_event_without_preload_content(
    self,
    project_id: StrictStr,
    create_custom_event: CreateCustomEvent,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a new custom event.

    Warning: this endpoint allows to create custom events with a code larger than 20 characters (max 50), but the endpoint for creating a custom notification subscription (POST /api/projects/{projectId}/customNotificationSubscriptions) only accepts event codes up to 20 characters.

    :param project_id: (required)
    :type project_id: str
    :param create_custom_event: (required)
    :type create_custom_event: CreateCustomEvent
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_custom_event_serialize(
        project_id=project_id,
        create_custom_event=create_custom_event,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a new custom event.

Warning: this endpoint allows to create custom events with a code larger than 20 characters (max 50), but the endpoint for creating a custom notification subscription (POST /api/projects/{projectId}/customNotificationSubscriptions) only accepts event codes up to 20 characters.

:param project_id: (required) :type project_id: str :param create_custom_event: (required) :type create_custom_event: CreateCustomEvent :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectCustomNotificationSubscriptionsApi (api_client=None)

Expand source code

class ProjectCustomNotificationSubscriptionsApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_custom_notification_subscription(
        self,
        project_id: StrictStr,
        create_custom_notification_subscription: Annotated[CreateCustomNotificationSubscription, Field(description="The new subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> CustomNotificationSubscription:
        """Create a custom notification subscription


        :param project_id: (required)
        :type project_id: str
        :param create_custom_notification_subscription: The new subscription (required)
        :type create_custom_notification_subscription: CreateCustomNotificationSubscription
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_custom_notification_subscription_serialize(
            project_id=project_id,
            create_custom_notification_subscription=create_custom_notification_subscription,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_custom_notification_subscription_with_http_info(
        self,
        project_id: StrictStr,
        create_custom_notification_subscription: Annotated[CreateCustomNotificationSubscription, Field(description="The new subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[CustomNotificationSubscription]:
        """Create a custom notification subscription


        :param project_id: (required)
        :type project_id: str
        :param create_custom_notification_subscription: The new subscription (required)
        :type create_custom_notification_subscription: CreateCustomNotificationSubscription
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_custom_notification_subscription_serialize(
            project_id=project_id,
            create_custom_notification_subscription=create_custom_notification_subscription,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_custom_notification_subscription_without_preload_content(
        self,
        project_id: StrictStr,
        create_custom_notification_subscription: Annotated[CreateCustomNotificationSubscription, Field(description="The new subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a custom notification subscription


        :param project_id: (required)
        :type project_id: str
        :param create_custom_notification_subscription: The new subscription (required)
        :type create_custom_notification_subscription: CreateCustomNotificationSubscription
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_custom_notification_subscription_serialize(
            project_id=project_id,
            create_custom_notification_subscription=create_custom_notification_subscription,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_custom_notification_subscription_serialize(
        self,
        project_id,
        create_custom_notification_subscription,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_custom_notification_subscription is not None:
            _body_params = create_custom_notification_subscription


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/customNotificationSubscriptions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_custom_notification_subscription(
        self,
        project_id: StrictStr,
        subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to delete")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a custom notification subscription


        :param project_id: (required)
        :type project_id: str
        :param subscription_id: The ID of the custom notification subscription to delete (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_custom_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_custom_notification_subscription_with_http_info(
        self,
        project_id: StrictStr,
        subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to delete")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a custom notification subscription


        :param project_id: (required)
        :type project_id: str
        :param subscription_id: The ID of the custom notification subscription to delete (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_custom_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_custom_notification_subscription_without_preload_content(
        self,
        project_id: StrictStr,
        subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to delete")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a custom notification subscription


        :param project_id: (required)
        :type project_id: str
        :param subscription_id: The ID of the custom notification subscription to delete (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_custom_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_custom_notification_subscription_serialize(
        self,
        project_id,
        subscription_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if subscription_id is not None:
            _path_params['subscriptionId'] = subscription_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/projects/{projectId}/customNotificationSubscriptions/{subscriptionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_custom_notification_subscription(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> CustomNotificationSubscription:
        """Retrieve a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_custom_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_custom_notification_subscription_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[CustomNotificationSubscription]:
        """Retrieve a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_custom_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_custom_notification_subscription_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_custom_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_custom_notification_subscription_serialize(
        self,
        project_id,
        subscription_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if subscription_id is not None:
            _path_params['subscriptionId'] = subscription_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/customNotificationSubscriptions/{subscriptionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_custom_notification_subscriptions(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> CustomNotificationSubscriptionList:
        """Retrieve notification subscriptions


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_custom_notification_subscriptions_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscriptionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_custom_notification_subscriptions_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[CustomNotificationSubscriptionList]:
        """Retrieve notification subscriptions


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_custom_notification_subscriptions_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscriptionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_custom_notification_subscriptions_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve notification subscriptions


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_custom_notification_subscriptions_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscriptionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_custom_notification_subscriptions_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/customNotificationSubscriptions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_custom_notification_subscription(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to update")],
        custom_notification_subscription: Annotated[CustomNotificationSubscription, Field(description="The updated subscription")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> CustomNotificationSubscription:
        """Update a notification subscription

        Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the custom notification subscription to update (required)
        :type subscription_id: str
        :param custom_notification_subscription: The updated subscription (required)
        :type custom_notification_subscription: CustomNotificationSubscription
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_custom_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            custom_notification_subscription=custom_notification_subscription,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_custom_notification_subscription_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to update")],
        custom_notification_subscription: Annotated[CustomNotificationSubscription, Field(description="The updated subscription")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[CustomNotificationSubscription]:
        """Update a notification subscription

        Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the custom notification subscription to update (required)
        :type subscription_id: str
        :param custom_notification_subscription: The updated subscription (required)
        :type custom_notification_subscription: CustomNotificationSubscription
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_custom_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            custom_notification_subscription=custom_notification_subscription,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_custom_notification_subscription_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to update")],
        custom_notification_subscription: Annotated[CustomNotificationSubscription, Field(description="The updated subscription")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a notification subscription

        Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the custom notification subscription to update (required)
        :type subscription_id: str
        :param custom_notification_subscription: The updated subscription (required)
        :type custom_notification_subscription: CustomNotificationSubscription
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_custom_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            custom_notification_subscription=custom_notification_subscription,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "CustomNotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_custom_notification_subscription_serialize(
        self,
        project_id,
        subscription_id,
        custom_notification_subscription,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if subscription_id is not None:
            _path_params['subscriptionId'] = subscription_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if custom_notification_subscription is not None:
            _body_params = custom_notification_subscription


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/customNotificationSubscriptions/{subscriptionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_custom_notification_subscription(self,
project_id: Annotated[str, Strict(strict=True)],
create_custom_notification_subscription: Annotated[CreateCustomNotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The new subscription')]) ‑> CustomNotificationSubscription

Expand source code

@validate_call
def create_custom_notification_subscription(
    self,
    project_id: StrictStr,
    create_custom_notification_subscription: Annotated[CreateCustomNotificationSubscription, Field(description="The new subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> CustomNotificationSubscription:
    """Create a custom notification subscription


    :param project_id: (required)
    :type project_id: str
    :param create_custom_notification_subscription: The new subscription (required)
    :type create_custom_notification_subscription: CreateCustomNotificationSubscription
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_custom_notification_subscription_serialize(
        project_id=project_id,
        create_custom_notification_subscription=create_custom_notification_subscription,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a custom notification subscription

:param project_id: (required) :type project_id: str :param create_custom_notification_subscription: The new subscription (required) :type create_custom_notification_subscription: CreateCustomNotificationSubscription :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_custom_notification_subscription_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_custom_notification_subscription: Annotated[CreateCustomNotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The new subscription')]) ‑> ApiResponse[CustomNotificationSubscription]

Expand source code

@validate_call
def create_custom_notification_subscription_with_http_info(
    self,
    project_id: StrictStr,
    create_custom_notification_subscription: Annotated[CreateCustomNotificationSubscription, Field(description="The new subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[CustomNotificationSubscription]:
    """Create a custom notification subscription


    :param project_id: (required)
    :type project_id: str
    :param create_custom_notification_subscription: The new subscription (required)
    :type create_custom_notification_subscription: CreateCustomNotificationSubscription
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_custom_notification_subscription_serialize(
        project_id=project_id,
        create_custom_notification_subscription=create_custom_notification_subscription,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a custom notification subscription

:param project_id: (required) :type project_id: str :param create_custom_notification_subscription: The new subscription (required) :type create_custom_notification_subscription: CreateCustomNotificationSubscription :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_custom_notification_subscription_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_custom_notification_subscription: Annotated[CreateCustomNotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The new subscription')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_custom_notification_subscription_without_preload_content(
    self,
    project_id: StrictStr,
    create_custom_notification_subscription: Annotated[CreateCustomNotificationSubscription, Field(description="The new subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a custom notification subscription


    :param project_id: (required)
    :type project_id: str
    :param create_custom_notification_subscription: The new subscription (required)
    :type create_custom_notification_subscription: CreateCustomNotificationSubscription
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_custom_notification_subscription_serialize(
        project_id=project_id,
        create_custom_notification_subscription=create_custom_notification_subscription,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a custom notification subscription

:param project_id: (required) :type project_id: str :param create_custom_notification_subscription: The new subscription (required) :type create_custom_notification_subscription: CreateCustomNotificationSubscription :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_custom_notification_subscription(self,
project_id: Annotated[str, Strict(strict=True)],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the custom notification subscription to delete')]) ‑> None

Expand source code

@validate_call
def delete_custom_notification_subscription(
    self,
    project_id: StrictStr,
    subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to delete")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete a custom notification subscription


    :param project_id: (required)
    :type project_id: str
    :param subscription_id: The ID of the custom notification subscription to delete (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_custom_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete a custom notification subscription

:param project_id: (required) :type project_id: str :param subscription_id: The ID of the custom notification subscription to delete (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_custom_notification_subscription_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the custom notification subscription to delete')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_custom_notification_subscription_with_http_info(
    self,
    project_id: StrictStr,
    subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to delete")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete a custom notification subscription


    :param project_id: (required)
    :type project_id: str
    :param subscription_id: The ID of the custom notification subscription to delete (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_custom_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete a custom notification subscription

:param project_id: (required) :type project_id: str :param subscription_id: The ID of the custom notification subscription to delete (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_custom_notification_subscription_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the custom notification subscription to delete')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_custom_notification_subscription_without_preload_content(
    self,
    project_id: StrictStr,
    subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to delete")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete a custom notification subscription


    :param project_id: (required)
    :type project_id: str
    :param subscription_id: The ID of the custom notification subscription to delete (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_custom_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete a custom notification subscription

:param project_id: (required) :type project_id: str :param subscription_id: The ID of the custom notification subscription to delete (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_custom_notification_subscription(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription')]) ‑> CustomNotificationSubscription

Expand source code

@validate_call
def get_custom_notification_subscription(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> CustomNotificationSubscription:
    """Retrieve a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_custom_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_custom_notification_subscription_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription')]) ‑> ApiResponse[CustomNotificationSubscription]

Expand source code

@validate_call
def get_custom_notification_subscription_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[CustomNotificationSubscription]:
    """Retrieve a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_custom_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_custom_notification_subscription_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_custom_notification_subscription_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_custom_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_custom_notification_subscriptions(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')]) ‑> CustomNotificationSubscriptionList

Expand source code

@validate_call
def get_custom_notification_subscriptions(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> CustomNotificationSubscriptionList:
    """Retrieve notification subscriptions


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_custom_notification_subscriptions_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscriptionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve notification subscriptions

:param project_id: The ID of the project (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_custom_notification_subscriptions_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')]) ‑> ApiResponse[CustomNotificationSubscriptionList]

Expand source code

@validate_call
def get_custom_notification_subscriptions_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[CustomNotificationSubscriptionList]:
    """Retrieve notification subscriptions


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_custom_notification_subscriptions_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscriptionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve notification subscriptions

:param project_id: The ID of the project (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_custom_notification_subscriptions_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_custom_notification_subscriptions_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve notification subscriptions


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_custom_notification_subscriptions_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscriptionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve notification subscriptions

:param project_id: The ID of the project (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_custom_notification_subscription(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the custom notification subscription to update')],
custom_notification_subscription: Annotated[CustomNotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The updated subscription')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> CustomNotificationSubscription

Expand source code

@validate_call
def update_custom_notification_subscription(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to update")],
    custom_notification_subscription: Annotated[CustomNotificationSubscription, Field(description="The updated subscription")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> CustomNotificationSubscription:
    """Update a notification subscription

    Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the custom notification subscription to update (required)
    :type subscription_id: str
    :param custom_notification_subscription: The updated subscription (required)
    :type custom_notification_subscription: CustomNotificationSubscription
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_custom_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        custom_notification_subscription=custom_notification_subscription,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update a notification subscription

Fields which can be updated: - enabled - eventCode - filterExpression - notificationChannel

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the custom notification subscription to update (required) :type subscription_id: str :param custom_notification_subscription: The updated subscription (required) :type custom_notification_subscription: CustomNotificationSubscription :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_custom_notification_subscription_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the custom notification subscription to update')],
custom_notification_subscription: Annotated[CustomNotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The updated subscription')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[CustomNotificationSubscription]

Expand source code

@validate_call
def update_custom_notification_subscription_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to update")],
    custom_notification_subscription: Annotated[CustomNotificationSubscription, Field(description="The updated subscription")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[CustomNotificationSubscription]:
    """Update a notification subscription

    Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the custom notification subscription to update (required)
    :type subscription_id: str
    :param custom_notification_subscription: The updated subscription (required)
    :type custom_notification_subscription: CustomNotificationSubscription
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_custom_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        custom_notification_subscription=custom_notification_subscription,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update a notification subscription

Fields which can be updated: - enabled - eventCode - filterExpression - notificationChannel

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the custom notification subscription to update (required) :type subscription_id: str :param custom_notification_subscription: The updated subscription (required) :type custom_notification_subscription: CustomNotificationSubscription :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_custom_notification_subscription_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the custom notification subscription to update')],
custom_notification_subscription: Annotated[CustomNotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The updated subscription')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_custom_notification_subscription_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the custom notification subscription to update")],
    custom_notification_subscription: Annotated[CustomNotificationSubscription, Field(description="The updated subscription")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update a notification subscription

    Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the custom notification subscription to update (required)
    :type subscription_id: str
    :param custom_notification_subscription: The updated subscription (required)
    :type custom_notification_subscription: CustomNotificationSubscription
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_custom_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        custom_notification_subscription=custom_notification_subscription,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "CustomNotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update a notification subscription

Fields which can be updated: - enabled - eventCode - filterExpression - notificationChannel

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the custom notification subscription to update (required) :type subscription_id: str :param custom_notification_subscription: The updated subscription (required) :type custom_notification_subscription: CustomNotificationSubscription :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectData (**data: Any)

Expand source code

class ProjectData(BaseModel):
    """
    ProjectData
    """ # noqa: E501
    data: Data
    project_id: StrictStr = Field(alias="projectId")
    __properties: ClassVar[List[str]] = ["data", "projectId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of data
        if self.data:
            _dict['data'] = self.data.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "data": Data.from_dict(obj["data"]) if obj.get("data") is not None else None,
            "projectId": obj.get("projectId")
        })
        return _obj

ProjectData

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data : Data

The type of the None singleton.

var model_config

The type of the None singleton.

var project_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of data
    if self.data:
        _dict['data'] = self.data.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataAndTemporaryCredentials (**data: Any)

Expand source code

class ProjectDataAndTemporaryCredentials(BaseModel):
    """
    ProjectDataAndTemporaryCredentials
    """ # noqa: E501
    data: Data
    project_id: StrictStr = Field(alias="projectId")
    temp_credentials: Optional[TempCredentials] = Field(alias="tempCredentials")
    __properties: ClassVar[List[str]] = ["data", "projectId", "tempCredentials"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataAndTemporaryCredentials from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of data
        if self.data:
            _dict['data'] = self.data.to_dict()
        # override the default output from pydantic by calling `to_dict()` of temp_credentials
        if self.temp_credentials:
            _dict['tempCredentials'] = self.temp_credentials.to_dict()
        # set to None if temp_credentials (nullable) is None
        # and model_fields_set contains the field
        if self.temp_credentials is None and "temp_credentials" in self.model_fields_set:
            _dict['tempCredentials'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataAndTemporaryCredentials from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "data": Data.from_dict(obj["data"]) if obj.get("data") is not None else None,
            "projectId": obj.get("projectId"),
            "tempCredentials": TempCredentials.from_dict(obj["tempCredentials"]) if obj.get("tempCredentials") is not None else None
        })
        return _obj

ProjectDataAndTemporaryCredentials

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data : Data

The type of the None singleton.

var model_config

The type of the None singleton.

var project_id : str

The type of the None singleton.

var temp_credentials : TempCredentials | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataAndTemporaryCredentials from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataAndTemporaryCredentials from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of data
    if self.data:
        _dict['data'] = self.data.to_dict()
    # override the default output from pydantic by calling `to_dict()` of temp_credentials
    if self.temp_credentials:
        _dict['tempCredentials'] = self.temp_credentials.to_dict()
    # set to None if temp_credentials (nullable) is None
    # and model_fields_set contains the field
    if self.temp_credentials is None and "temp_credentials" in self.model_fields_set:
        _dict['tempCredentials'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataApi (api_client=None)

Expand source code

class ProjectDataApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def add_secondary_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        secondary_data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Add secondary data to data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param secondary_data_id: (required)
        :type secondary_data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._add_secondary_data_serialize(
            project_id=project_id,
            data_id=data_id,
            secondary_data_id=secondary_data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def add_secondary_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        secondary_data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Add secondary data to data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param secondary_data_id: (required)
        :type secondary_data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._add_secondary_data_serialize(
            project_id=project_id,
            data_id=data_id,
            secondary_data_id=secondary_data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def add_secondary_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        secondary_data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Add secondary data to data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param secondary_data_id: (required)
        :type secondary_data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._add_secondary_data_serialize(
            project_id=project_id,
            data_id=data_id,
            secondary_data_id=secondary_data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _add_secondary_data_serialize(
        self,
        project_id,
        data_id,
        secondary_data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        if secondary_data_id is not None:
            _path_params['secondaryDataId'] = secondary_data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}/secondaryData/{secondaryDataId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def archive_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Schedule this data for archival.

        Endpoint for scheduling this data for archival. This will also archive all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._archive_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def archive_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Schedule this data for archival.

        Endpoint for scheduling this data for archival. This will also archive all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._archive_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def archive_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Schedule this data for archival.

        Endpoint for scheduling this data for archival. This will also archive all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._archive_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _archive_data_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}:archive',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def complete_folder_upload_session(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        folder_upload_session_id: StrictStr,
        complete_folder_upload_session: Annotated[CompleteFolderUploadSession, Field(description="The info required to complete the folder upload session.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> FolderUploadSession:
        """Complete a trackable folder upload session.

        Complete a trackable folder upload session. By completing the folder upload session, and specifying how many files you have uploaded, ICA can ensure that all uploaded files are accounted for.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param folder_upload_session_id: (required)
        :type folder_upload_session_id: str
        :param complete_folder_upload_session: The info required to complete the folder upload session. (required)
        :type complete_folder_upload_session: CompleteFolderUploadSession
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._complete_folder_upload_session_serialize(
            project_id=project_id,
            data_id=data_id,
            folder_upload_session_id=folder_upload_session_id,
            complete_folder_upload_session=complete_folder_upload_session,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "FolderUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def complete_folder_upload_session_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        folder_upload_session_id: StrictStr,
        complete_folder_upload_session: Annotated[CompleteFolderUploadSession, Field(description="The info required to complete the folder upload session.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[FolderUploadSession]:
        """Complete a trackable folder upload session.

        Complete a trackable folder upload session. By completing the folder upload session, and specifying how many files you have uploaded, ICA can ensure that all uploaded files are accounted for.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param folder_upload_session_id: (required)
        :type folder_upload_session_id: str
        :param complete_folder_upload_session: The info required to complete the folder upload session. (required)
        :type complete_folder_upload_session: CompleteFolderUploadSession
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._complete_folder_upload_session_serialize(
            project_id=project_id,
            data_id=data_id,
            folder_upload_session_id=folder_upload_session_id,
            complete_folder_upload_session=complete_folder_upload_session,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "FolderUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def complete_folder_upload_session_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        folder_upload_session_id: StrictStr,
        complete_folder_upload_session: Annotated[CompleteFolderUploadSession, Field(description="The info required to complete the folder upload session.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Complete a trackable folder upload session.

        Complete a trackable folder upload session. By completing the folder upload session, and specifying how many files you have uploaded, ICA can ensure that all uploaded files are accounted for.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param folder_upload_session_id: (required)
        :type folder_upload_session_id: str
        :param complete_folder_upload_session: The info required to complete the folder upload session. (required)
        :type complete_folder_upload_session: CompleteFolderUploadSession
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._complete_folder_upload_session_serialize(
            project_id=project_id,
            data_id=data_id,
            folder_upload_session_id=folder_upload_session_id,
            complete_folder_upload_session=complete_folder_upload_session,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "FolderUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _complete_folder_upload_session_serialize(
        self,
        project_id,
        data_id,
        folder_upload_session_id,
        complete_folder_upload_session,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        if folder_upload_session_id is not None:
            _path_params['folderUploadSessionId'] = folder_upload_session_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if complete_folder_upload_session is not None:
            _body_params = complete_folder_upload_session


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}/folderUploadSessions/{folderUploadSessionId}:complete',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_data_in_project(
        self,
        project_id: StrictStr,
        create_data: Annotated[CreateData, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectData:
        """(Deprecated) Create data in this project.


        :param project_id: (required)
        :type project_id: str
        :param create_data: The data to create. (required)
        :type create_data: CreateData
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("POST /api/projects/{projectId}/data is deprecated.", DeprecationWarning)

        _param = self._create_data_in_project_serialize(
            project_id=project_id,
            create_data=create_data,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_data_in_project_with_http_info(
        self,
        project_id: StrictStr,
        create_data: Annotated[CreateData, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectData]:
        """(Deprecated) Create data in this project.


        :param project_id: (required)
        :type project_id: str
        :param create_data: The data to create. (required)
        :type create_data: CreateData
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("POST /api/projects/{projectId}/data is deprecated.", DeprecationWarning)

        _param = self._create_data_in_project_serialize(
            project_id=project_id,
            create_data=create_data,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_data_in_project_without_preload_content(
        self,
        project_id: StrictStr,
        create_data: Annotated[CreateData, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """(Deprecated) Create data in this project.


        :param project_id: (required)
        :type project_id: str
        :param create_data: The data to create. (required)
        :type create_data: CreateData
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("POST /api/projects/{projectId}/data is deprecated.", DeprecationWarning)

        _param = self._create_data_in_project_serialize(
            project_id=project_id,
            create_data=create_data,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_data_in_project_serialize(
        self,
        project_id,
        create_data,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_data is not None:
            _body_params = create_data


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_download_url_for_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Download:
        """Retrieve a download URL for this data.

        Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_url_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Download",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_download_url_for_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Download]:
        """Retrieve a download URL for this data.

        Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_url_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Download",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_download_url_for_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a download URL for this data.

        Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_url_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Download",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_download_url_for_data_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}:createDownloadUrl',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_download_urls_for_data(
        self,
        project_id: StrictStr,
        data_id_or_path_list: DataIdOrPathList,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DataUrlWithPathList:
        """Retrieve download URLs for the data.

        Can be used to download files directly from the region where it is located, no connector is needed. Not applicable for Folders.

        :param project_id: (required)
        :type project_id: str
        :param data_id_or_path_list: (required)
        :type data_id_or_path_list: DataIdOrPathList
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_urls_for_data_serialize(
            project_id=project_id,
            data_id_or_path_list=data_id_or_path_list,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataUrlWithPathList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_download_urls_for_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id_or_path_list: DataIdOrPathList,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DataUrlWithPathList]:
        """Retrieve download URLs for the data.

        Can be used to download files directly from the region where it is located, no connector is needed. Not applicable for Folders.

        :param project_id: (required)
        :type project_id: str
        :param data_id_or_path_list: (required)
        :type data_id_or_path_list: DataIdOrPathList
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_urls_for_data_serialize(
            project_id=project_id,
            data_id_or_path_list=data_id_or_path_list,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataUrlWithPathList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_download_urls_for_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id_or_path_list: DataIdOrPathList,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve download URLs for the data.

        Can be used to download files directly from the region where it is located, no connector is needed. Not applicable for Folders.

        :param project_id: (required)
        :type project_id: str
        :param data_id_or_path_list: (required)
        :type data_id_or_path_list: DataIdOrPathList
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_download_urls_for_data_serialize(
            project_id=project_id,
            data_id_or_path_list=data_id_or_path_list,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataUrlWithPathList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_download_urls_for_data_serialize(
        self,
        project_id,
        data_id_or_path_list,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if data_id_or_path_list is not None:
            _body_params = data_id_or_path_list


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data:createDownloadUrls',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_file(
        self,
        project_id: StrictStr,
        create_file_data: Annotated[CreateFileData, Field(description="The file to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectData:
        """Create a file in this project.


        :param project_id: (required)
        :type project_id: str
        :param create_file_data: The file to create. (required)
        :type create_file_data: CreateFileData
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_file_serialize(
            project_id=project_id,
            create_file_data=create_file_data,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_file_with_http_info(
        self,
        project_id: StrictStr,
        create_file_data: Annotated[CreateFileData, Field(description="The file to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectData]:
        """Create a file in this project.


        :param project_id: (required)
        :type project_id: str
        :param create_file_data: The file to create. (required)
        :type create_file_data: CreateFileData
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_file_serialize(
            project_id=project_id,
            create_file_data=create_file_data,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_file_without_preload_content(
        self,
        project_id: StrictStr,
        create_file_data: Annotated[CreateFileData, Field(description="The file to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a file in this project.


        :param project_id: (required)
        :type project_id: str
        :param create_file_data: The file to create. (required)
        :type create_file_data: CreateFileData
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_file_serialize(
            project_id=project_id,
            create_file_data=create_file_data,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_file_serialize(
        self,
        project_id,
        create_file_data,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_file_data is not None:
            _body_params = create_file_data


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data:createFile',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_file_with_temporary_credentials(
        self,
        project_id: StrictStr,
        create_file_and_temporary_credentials: Annotated[CreateFileAndTemporaryCredentials, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataAndTemporaryCredentials:
        """Create a file in this project, and retrieve temporary credentials for it.


        :param project_id: (required)
        :type project_id: str
        :param create_file_and_temporary_credentials: The data to create. (required)
        :type create_file_and_temporary_credentials: CreateFileAndTemporaryCredentials
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_file_with_temporary_credentials_serialize(
            project_id=project_id,
            create_file_and_temporary_credentials=create_file_and_temporary_credentials,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataAndTemporaryCredentials",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_file_with_temporary_credentials_with_http_info(
        self,
        project_id: StrictStr,
        create_file_and_temporary_credentials: Annotated[CreateFileAndTemporaryCredentials, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataAndTemporaryCredentials]:
        """Create a file in this project, and retrieve temporary credentials for it.


        :param project_id: (required)
        :type project_id: str
        :param create_file_and_temporary_credentials: The data to create. (required)
        :type create_file_and_temporary_credentials: CreateFileAndTemporaryCredentials
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_file_with_temporary_credentials_serialize(
            project_id=project_id,
            create_file_and_temporary_credentials=create_file_and_temporary_credentials,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataAndTemporaryCredentials",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_file_with_temporary_credentials_without_preload_content(
        self,
        project_id: StrictStr,
        create_file_and_temporary_credentials: Annotated[CreateFileAndTemporaryCredentials, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a file in this project, and retrieve temporary credentials for it.


        :param project_id: (required)
        :type project_id: str
        :param create_file_and_temporary_credentials: The data to create. (required)
        :type create_file_and_temporary_credentials: CreateFileAndTemporaryCredentials
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_file_with_temporary_credentials_serialize(
            project_id=project_id,
            create_file_and_temporary_credentials=create_file_and_temporary_credentials,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataAndTemporaryCredentials",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_file_with_temporary_credentials_serialize(
        self,
        project_id,
        create_file_and_temporary_credentials,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_file_and_temporary_credentials is not None:
            _body_params = create_file_and_temporary_credentials


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data:createFileWithTemporaryCredentials',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_file_with_upload_url(
        self,
        project_id: StrictStr,
        create_file_and_upload_url: Annotated[CreateFileAndUploadUrl, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectFileAndUploadUrl:
        """Create a file in this project, and retrieve an upload url for it.


        :param project_id: (required)
        :type project_id: str
        :param create_file_and_upload_url: The data to create. (required)
        :type create_file_and_upload_url: CreateFileAndUploadUrl
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_file_with_upload_url_serialize(
            project_id=project_id,
            create_file_and_upload_url=create_file_and_upload_url,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectFileAndUploadUrl",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_file_with_upload_url_with_http_info(
        self,
        project_id: StrictStr,
        create_file_and_upload_url: Annotated[CreateFileAndUploadUrl, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectFileAndUploadUrl]:
        """Create a file in this project, and retrieve an upload url for it.


        :param project_id: (required)
        :type project_id: str
        :param create_file_and_upload_url: The data to create. (required)
        :type create_file_and_upload_url: CreateFileAndUploadUrl
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_file_with_upload_url_serialize(
            project_id=project_id,
            create_file_and_upload_url=create_file_and_upload_url,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectFileAndUploadUrl",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_file_with_upload_url_without_preload_content(
        self,
        project_id: StrictStr,
        create_file_and_upload_url: Annotated[CreateFileAndUploadUrl, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a file in this project, and retrieve an upload url for it.


        :param project_id: (required)
        :type project_id: str
        :param create_file_and_upload_url: The data to create. (required)
        :type create_file_and_upload_url: CreateFileAndUploadUrl
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_file_with_upload_url_serialize(
            project_id=project_id,
            create_file_and_upload_url=create_file_and_upload_url,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectFileAndUploadUrl",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_file_with_upload_url_serialize(
        self,
        project_id,
        create_file_and_upload_url,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_file_and_upload_url is not None:
            _body_params = create_file_and_upload_url


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data:createFileWithUploadUrl',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_folder(
        self,
        project_id: StrictStr,
        create_folder: Annotated[CreateFolder, Field(description="The folder to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectData:
        """Create a folder in this project.


        :param project_id: (required)
        :type project_id: str
        :param create_folder: The folder to create. (required)
        :type create_folder: CreateFolder
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_serialize(
            project_id=project_id,
            create_folder=create_folder,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_folder_with_http_info(
        self,
        project_id: StrictStr,
        create_folder: Annotated[CreateFolder, Field(description="The folder to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectData]:
        """Create a folder in this project.


        :param project_id: (required)
        :type project_id: str
        :param create_folder: The folder to create. (required)
        :type create_folder: CreateFolder
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_serialize(
            project_id=project_id,
            create_folder=create_folder,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_folder_without_preload_content(
        self,
        project_id: StrictStr,
        create_folder: Annotated[CreateFolder, Field(description="The folder to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a folder in this project.


        :param project_id: (required)
        :type project_id: str
        :param create_folder: The folder to create. (required)
        :type create_folder: CreateFolder
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_serialize(
            project_id=project_id,
            create_folder=create_folder,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_folder_serialize(
        self,
        project_id,
        create_folder,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_folder is not None:
            _body_params = create_folder


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data:createFolder',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_folder_upload_session(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> FolderUploadSession:
        """Create a trackable folder upload session.

        This endpoint can be used to ensure that all uploaded files within the requested session are accounted for. This call has to be used together with the :complete endpoint once upload is done.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param create_temporary_credentials: Temporary credentials request options.
        :type create_temporary_credentials: CreateTemporaryCredentials
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_upload_session_serialize(
            project_id=project_id,
            data_id=data_id,
            create_temporary_credentials=create_temporary_credentials,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "FolderUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_folder_upload_session_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[FolderUploadSession]:
        """Create a trackable folder upload session.

        This endpoint can be used to ensure that all uploaded files within the requested session are accounted for. This call has to be used together with the :complete endpoint once upload is done.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param create_temporary_credentials: Temporary credentials request options.
        :type create_temporary_credentials: CreateTemporaryCredentials
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_upload_session_serialize(
            project_id=project_id,
            data_id=data_id,
            create_temporary_credentials=create_temporary_credentials,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "FolderUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_folder_upload_session_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a trackable folder upload session.

        This endpoint can be used to ensure that all uploaded files within the requested session are accounted for. This call has to be used together with the :complete endpoint once upload is done.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param create_temporary_credentials: Temporary credentials request options.
        :type create_temporary_credentials: CreateTemporaryCredentials
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_upload_session_serialize(
            project_id=project_id,
            data_id=data_id,
            create_temporary_credentials=create_temporary_credentials,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "FolderUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_folder_upload_session_serialize(
        self,
        project_id,
        data_id,
        create_temporary_credentials,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_temporary_credentials is not None:
            _body_params = create_temporary_credentials


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}/folderUploadSessions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_folder_with_temporary_credentials(
        self,
        project_id: StrictStr,
        create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataAndTemporaryCredentials:
        """Create a folder in this project, and and retrieve temporary credentials for it.


        :param project_id: (required)
        :type project_id: str
        :param create_folder_and_temporary_credentials: The data to create. (required)
        :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_with_temporary_credentials_serialize(
            project_id=project_id,
            create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataAndTemporaryCredentials",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_folder_with_temporary_credentials_with_http_info(
        self,
        project_id: StrictStr,
        create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataAndTemporaryCredentials]:
        """Create a folder in this project, and and retrieve temporary credentials for it.


        :param project_id: (required)
        :type project_id: str
        :param create_folder_and_temporary_credentials: The data to create. (required)
        :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_with_temporary_credentials_serialize(
            project_id=project_id,
            create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataAndTemporaryCredentials",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_folder_with_temporary_credentials_without_preload_content(
        self,
        project_id: StrictStr,
        create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a folder in this project, and and retrieve temporary credentials for it.


        :param project_id: (required)
        :type project_id: str
        :param create_folder_and_temporary_credentials: The data to create. (required)
        :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_with_temporary_credentials_serialize(
            project_id=project_id,
            create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataAndTemporaryCredentials",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_folder_with_temporary_credentials_serialize(
        self,
        project_id,
        create_folder_and_temporary_credentials,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_folder_and_temporary_credentials is not None:
            _body_params = create_folder_and_temporary_credentials


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data:createFolderWithTemporaryCredentials',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_folder_with_upload_session(
        self,
        project_id: StrictStr,
        create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectFolderAndUploadSession:
        """Create a folder in this project, and create a trackable folder upload session.


        :param project_id: (required)
        :type project_id: str
        :param create_folder_and_temporary_credentials: The data to create. (required)
        :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_with_upload_session_serialize(
            project_id=project_id,
            create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectFolderAndUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_folder_with_upload_session_with_http_info(
        self,
        project_id: StrictStr,
        create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectFolderAndUploadSession]:
        """Create a folder in this project, and create a trackable folder upload session.


        :param project_id: (required)
        :type project_id: str
        :param create_folder_and_temporary_credentials: The data to create. (required)
        :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_with_upload_session_serialize(
            project_id=project_id,
            create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectFolderAndUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_folder_with_upload_session_without_preload_content(
        self,
        project_id: StrictStr,
        create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a folder in this project, and create a trackable folder upload session.


        :param project_id: (required)
        :type project_id: str
        :param create_folder_and_temporary_credentials: The data to create. (required)
        :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_folder_with_upload_session_serialize(
            project_id=project_id,
            create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectFolderAndUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_folder_with_upload_session_serialize(
        self,
        project_id,
        create_folder_and_temporary_credentials,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_folder_and_temporary_credentials is not None:
            _body_params = create_folder_and_temporary_credentials


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data:createFolderWithUploadSession',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_inline_view_url_for_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> InlineView:
        """Retrieve an URL for this data to use for inline view in a browser.

        Can be used to view a file directly from the region where it is located, no connector is needed.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_inline_view_url_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InlineView",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_inline_view_url_for_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[InlineView]:
        """Retrieve an URL for this data to use for inline view in a browser.

        Can be used to view a file directly from the region where it is located, no connector is needed.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_inline_view_url_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InlineView",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_inline_view_url_for_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve an URL for this data to use for inline view in a browser.

        Can be used to view a file directly from the region where it is located, no connector is needed.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_inline_view_url_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InlineView",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_inline_view_url_for_data_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}:createInlineViewUrl',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_non_indexed_folder(
        self,
        project_id: StrictStr,
        create_non_indexed_folder: Annotated[CreateNonIndexedFolder, Field(description="The non indexed folder to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectData:
        """Create a non indexed folder in this project. The folder will be created as a top-level folder.


        :param project_id: (required)
        :type project_id: str
        :param create_non_indexed_folder: The non indexed folder to create. (required)
        :type create_non_indexed_folder: CreateNonIndexedFolder
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_non_indexed_folder_serialize(
            project_id=project_id,
            create_non_indexed_folder=create_non_indexed_folder,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_non_indexed_folder_with_http_info(
        self,
        project_id: StrictStr,
        create_non_indexed_folder: Annotated[CreateNonIndexedFolder, Field(description="The non indexed folder to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectData]:
        """Create a non indexed folder in this project. The folder will be created as a top-level folder.


        :param project_id: (required)
        :type project_id: str
        :param create_non_indexed_folder: The non indexed folder to create. (required)
        :type create_non_indexed_folder: CreateNonIndexedFolder
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_non_indexed_folder_serialize(
            project_id=project_id,
            create_non_indexed_folder=create_non_indexed_folder,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_non_indexed_folder_without_preload_content(
        self,
        project_id: StrictStr,
        create_non_indexed_folder: Annotated[CreateNonIndexedFolder, Field(description="The non indexed folder to create.")],
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a non indexed folder in this project. The folder will be created as a top-level folder.


        :param project_id: (required)
        :type project_id: str
        :param create_non_indexed_folder: The non indexed folder to create. (required)
        :type create_non_indexed_folder: CreateNonIndexedFolder
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_non_indexed_folder_serialize(
            project_id=project_id,
            create_non_indexed_folder=create_non_indexed_folder,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_non_indexed_folder_serialize(
        self,
        project_id,
        create_non_indexed_folder,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_non_indexed_folder is not None:
            _body_params = create_non_indexed_folder


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data:createNonIndexedFolder',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_temporary_credentials_for_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> TempCredentials:
        """Retrieve temporary credentials for this data.

        Can be used to upload or download a file directly from the region where it is located, no connector is needed. The returned credentials expire after 36 hours.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param create_temporary_credentials: Temporary credentials request options.
        :type create_temporary_credentials: CreateTemporaryCredentials
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_temporary_credentials_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            create_temporary_credentials=create_temporary_credentials,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TempCredentials",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_temporary_credentials_for_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[TempCredentials]:
        """Retrieve temporary credentials for this data.

        Can be used to upload or download a file directly from the region where it is located, no connector is needed. The returned credentials expire after 36 hours.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param create_temporary_credentials: Temporary credentials request options.
        :type create_temporary_credentials: CreateTemporaryCredentials
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_temporary_credentials_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            create_temporary_credentials=create_temporary_credentials,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TempCredentials",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_temporary_credentials_for_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve temporary credentials for this data.

        Can be used to upload or download a file directly from the region where it is located, no connector is needed. The returned credentials expire after 36 hours.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param create_temporary_credentials: Temporary credentials request options.
        :type create_temporary_credentials: CreateTemporaryCredentials
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_temporary_credentials_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            create_temporary_credentials=create_temporary_credentials,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "TempCredentials",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_temporary_credentials_for_data_serialize(
        self,
        project_id,
        data_id,
        create_temporary_credentials,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_temporary_credentials is not None:
            _body_params = create_temporary_credentials


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}:createTemporaryCredentials',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_upload_url_for_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        file_type: Optional[StrictStr] = None,
        hash: Optional[StrictStr] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Upload:
        """Retrieve an upload URL for this data.

        Can be used to upload a file directly from the region where it is located, no connector is needed. The project identifier must match the project which owns the data. You can create both new files and overwrite files in status 'partial'.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param file_type:
        :type file_type: str
        :param hash:
        :type hash: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_upload_url_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            file_type=file_type,
            hash=hash,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Upload",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_upload_url_for_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        file_type: Optional[StrictStr] = None,
        hash: Optional[StrictStr] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Upload]:
        """Retrieve an upload URL for this data.

        Can be used to upload a file directly from the region where it is located, no connector is needed. The project identifier must match the project which owns the data. You can create both new files and overwrite files in status 'partial'.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param file_type:
        :type file_type: str
        :param hash:
        :type hash: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_upload_url_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            file_type=file_type,
            hash=hash,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Upload",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_upload_url_for_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        file_type: Optional[StrictStr] = None,
        hash: Optional[StrictStr] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve an upload URL for this data.

        Can be used to upload a file directly from the region where it is located, no connector is needed. The project identifier must match the project which owns the data. You can create both new files and overwrite files in status 'partial'.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param file_type:
        :type file_type: str
        :param hash:
        :type hash: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_upload_url_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            file_type=file_type,
            hash=hash,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Upload",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_upload_url_for_data_serialize(
        self,
        project_id,
        data_id,
        file_type,
        hash,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        if file_type is not None:
            
            _query_params.append(('fileType', file_type))
            
        if hash is not None:
            
            _query_params.append(('hash', hash))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}:createUploadUrl',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Schedule this data for deletion.

        Endpoint for scheduling this data for deletion. This will also delete all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Schedule this data for deletion.

        Endpoint for scheduling this data for deletion. This will also delete all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Schedule this data for deletion.

        Endpoint for scheduling this data for deletion. This will also delete all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_data_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}:delete',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_data_eligible_for_linking(
        self,
        project_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DataPagedList:
        """Retrieve a list of data eligible for linking to the current project.


        :param project_id: (required)
        :type project_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: List[str]
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: List[str]
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.
        :type not_linked_to_sample: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_eligible_for_linking_serialize(
            project_id=project_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_data_eligible_for_linking_with_http_info(
        self,
        project_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DataPagedList]:
        """Retrieve a list of data eligible for linking to the current project.


        :param project_id: (required)
        :type project_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: List[str]
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: List[str]
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.
        :type not_linked_to_sample: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_eligible_for_linking_serialize(
            project_id=project_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_data_eligible_for_linking_without_preload_content(
        self,
        project_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of data eligible for linking to the current project.


        :param project_id: (required)
        :type project_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: List[str]
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: List[str]
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.
        :type not_linked_to_sample: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_eligible_for_linking_serialize(
            project_id=project_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_data_eligible_for_linking_serialize(
        self,
        project_id,
        full_text,
        id,
        filename,
        filename_match_mode,
        file_path,
        file_path_match_mode,
        status,
        format_id,
        format_code,
        type,
        parent_folder_id,
        parent_folder_path,
        creation_date_after,
        creation_date_before,
        status_date_after,
        status_date_before,
        user_tag,
        user_tag_match_mode,
        run_input_tag,
        run_input_tag_match_mode,
        run_output_tag,
        run_output_tag_match_mode,
        connector_tag,
        connector_tag_match_mode,
        technical_tag,
        technical_tag_match_mode,
        not_in_run,
        not_linked_to_sample,
        instrument_run_id,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'id': 'multi',
            'filename': 'multi',
            'filePath': 'multi',
            'status': 'multi',
            'formatId': 'multi',
            'formatCode': 'multi',
            'parentFolderId': 'multi',
            'userTag': 'multi',
            'runInputTag': 'multi',
            'runOutputTag': 'multi',
            'connectorTag': 'multi',
            'technicalTag': 'multi',
            'instrumentRunId': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if full_text is not None:
            
            _query_params.append(('fullText', full_text))
            
        if id is not None:
            
            _query_params.append(('id', id))
            
        if filename is not None:
            
            _query_params.append(('filename', filename))
            
        if filename_match_mode is not None:
            
            _query_params.append(('filenameMatchMode', filename_match_mode))
            
        if file_path is not None:
            
            _query_params.append(('filePath', file_path))
            
        if file_path_match_mode is not None:
            
            _query_params.append(('filePathMatchMode', file_path_match_mode))
            
        if status is not None:
            
            _query_params.append(('status', status))
            
        if format_id is not None:
            
            _query_params.append(('formatId', format_id))
            
        if format_code is not None:
            
            _query_params.append(('formatCode', format_code))
            
        if type is not None:
            
            _query_params.append(('type', type))
            
        if parent_folder_id is not None:
            
            _query_params.append(('parentFolderId', parent_folder_id))
            
        if parent_folder_path is not None:
            
            _query_params.append(('parentFolderPath', parent_folder_path))
            
        if creation_date_after is not None:
            if isinstance(creation_date_after, datetime):
                _query_params.append(
                    (
                        'creationDateAfter',
                        creation_date_after.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('creationDateAfter', creation_date_after))
            
        if creation_date_before is not None:
            if isinstance(creation_date_before, datetime):
                _query_params.append(
                    (
                        'creationDateBefore',
                        creation_date_before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('creationDateBefore', creation_date_before))
            
        if status_date_after is not None:
            if isinstance(status_date_after, datetime):
                _query_params.append(
                    (
                        'statusDateAfter',
                        status_date_after.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('statusDateAfter', status_date_after))
            
        if status_date_before is not None:
            if isinstance(status_date_before, datetime):
                _query_params.append(
                    (
                        'statusDateBefore',
                        status_date_before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('statusDateBefore', status_date_before))
            
        if user_tag is not None:
            
            _query_params.append(('userTag', user_tag))
            
        if user_tag_match_mode is not None:
            
            _query_params.append(('userTagMatchMode', user_tag_match_mode))
            
        if run_input_tag is not None:
            
            _query_params.append(('runInputTag', run_input_tag))
            
        if run_input_tag_match_mode is not None:
            
            _query_params.append(('runInputTagMatchMode', run_input_tag_match_mode))
            
        if run_output_tag is not None:
            
            _query_params.append(('runOutputTag', run_output_tag))
            
        if run_output_tag_match_mode is not None:
            
            _query_params.append(('runOutputTagMatchMode', run_output_tag_match_mode))
            
        if connector_tag is not None:
            
            _query_params.append(('connectorTag', connector_tag))
            
        if connector_tag_match_mode is not None:
            
            _query_params.append(('connectorTagMatchMode', connector_tag_match_mode))
            
        if technical_tag is not None:
            
            _query_params.append(('technicalTag', technical_tag))
            
        if technical_tag_match_mode is not None:
            
            _query_params.append(('technicalTagMatchMode', technical_tag_match_mode))
            
        if not_in_run is not None:
            
            _query_params.append(('notInRun', not_in_run))
            
        if not_linked_to_sample is not None:
            
            _query_params.append(('notLinkedToSample', not_linked_to_sample))
            
        if instrument_run_id is not None:
            
            _query_params.append(('instrumentRunId', instrument_run_id))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/data/eligibleForLinking',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_folder_upload_session(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        folder_upload_session_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> FolderUploadSession:
        """Retrieve folder upload session details.

        Retrieve folder upload session details, including the current status of your upload session.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param folder_upload_session_id: (required)
        :type folder_upload_session_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_folder_upload_session_serialize(
            project_id=project_id,
            data_id=data_id,
            folder_upload_session_id=folder_upload_session_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "FolderUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_folder_upload_session_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        folder_upload_session_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[FolderUploadSession]:
        """Retrieve folder upload session details.

        Retrieve folder upload session details, including the current status of your upload session.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param folder_upload_session_id: (required)
        :type folder_upload_session_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_folder_upload_session_serialize(
            project_id=project_id,
            data_id=data_id,
            folder_upload_session_id=folder_upload_session_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "FolderUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_folder_upload_session_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        folder_upload_session_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve folder upload session details.

        Retrieve folder upload session details, including the current status of your upload session.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param folder_upload_session_id: (required)
        :type folder_upload_session_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_folder_upload_session_serialize(
            project_id=project_id,
            data_id=data_id,
            folder_upload_session_id=folder_upload_session_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "FolderUploadSession",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_folder_upload_session_serialize(
        self,
        project_id,
        data_id,
        folder_upload_session_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        if folder_upload_session_id is not None:
            _path_params['folderUploadSessionId'] = folder_upload_session_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/data/{dataId}/folderUploadSessions/{folderUploadSessionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_non_sample_project_data(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataPagedList:
        """Retrieve a list of project data not linked to a sample.


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_non_sample_project_data_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_non_sample_project_data_with_http_info(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataPagedList]:
        """Retrieve a list of project data not linked to a sample.


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_non_sample_project_data_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_non_sample_project_data_without_preload_content(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of project data not linked to a sample.


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_non_sample_project_data_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_non_sample_project_data_serialize(
        self,
        project_id,
        page_offset,
        page_token,
        page_size,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/data/nonSampleData',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectData:
        """Retrieve a project data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectData]:
        """Retrieve a project data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/data/{dataId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_children(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataPagedList:
        """Retrieve the children of this data.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added pagination 

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
        :type not_linked_to_sample: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_children_serialize(
            project_id=project_id,
            data_id=data_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_children_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataPagedList]:
        """Retrieve the children of this data.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added pagination 

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
        :type not_linked_to_sample: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_children_serialize(
            project_id=project_id,
            data_id=data_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_children_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the children of this data.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added pagination 

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
        :type not_linked_to_sample: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_children_serialize(
            project_id=project_id,
            data_id=data_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_children_serialize(
        self,
        project_id,
        data_id,
        full_text,
        id,
        filename,
        filename_match_mode,
        status,
        format_id,
        format_code,
        type,
        creation_date_after,
        creation_date_before,
        status_date_after,
        status_date_before,
        user_tag,
        user_tag_match_mode,
        run_input_tag,
        run_input_tag_match_mode,
        run_output_tag,
        run_output_tag_match_mode,
        connector_tag,
        connector_tag_match_mode,
        technical_tag,
        technical_tag_match_mode,
        not_in_run,
        not_linked_to_sample,
        instrument_run_id,
        page_offset,
        page_token,
        page_size,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'id': 'multi',
            'filename': 'multi',
            'status': 'multi',
            'formatId': 'multi',
            'formatCode': 'multi',
            'userTag': 'multi',
            'runInputTag': 'multi',
            'runOutputTag': 'multi',
            'connectorTag': 'multi',
            'technicalTag': 'multi',
            'instrumentRunId': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        if full_text is not None:
            
            _query_params.append(('fullText', full_text))
            
        if id is not None:
            
            _query_params.append(('id', id))
            
        if filename is not None:
            
            _query_params.append(('filename', filename))
            
        if filename_match_mode is not None:
            
            _query_params.append(('filenameMatchMode', filename_match_mode))
            
        if status is not None:
            
            _query_params.append(('status', status))
            
        if format_id is not None:
            
            _query_params.append(('formatId', format_id))
            
        if format_code is not None:
            
            _query_params.append(('formatCode', format_code))
            
        if type is not None:
            
            _query_params.append(('type', type))
            
        if creation_date_after is not None:
            if isinstance(creation_date_after, datetime):
                _query_params.append(
                    (
                        'creationDateAfter',
                        creation_date_after.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('creationDateAfter', creation_date_after))
            
        if creation_date_before is not None:
            if isinstance(creation_date_before, datetime):
                _query_params.append(
                    (
                        'creationDateBefore',
                        creation_date_before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('creationDateBefore', creation_date_before))
            
        if status_date_after is not None:
            if isinstance(status_date_after, datetime):
                _query_params.append(
                    (
                        'statusDateAfter',
                        status_date_after.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('statusDateAfter', status_date_after))
            
        if status_date_before is not None:
            if isinstance(status_date_before, datetime):
                _query_params.append(
                    (
                        'statusDateBefore',
                        status_date_before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('statusDateBefore', status_date_before))
            
        if user_tag is not None:
            
            _query_params.append(('userTag', user_tag))
            
        if user_tag_match_mode is not None:
            
            _query_params.append(('userTagMatchMode', user_tag_match_mode))
            
        if run_input_tag is not None:
            
            _query_params.append(('runInputTag', run_input_tag))
            
        if run_input_tag_match_mode is not None:
            
            _query_params.append(('runInputTagMatchMode', run_input_tag_match_mode))
            
        if run_output_tag is not None:
            
            _query_params.append(('runOutputTag', run_output_tag))
            
        if run_output_tag_match_mode is not None:
            
            _query_params.append(('runOutputTagMatchMode', run_output_tag_match_mode))
            
        if connector_tag is not None:
            
            _query_params.append(('connectorTag', connector_tag))
            
        if connector_tag_match_mode is not None:
            
            _query_params.append(('connectorTagMatchMode', connector_tag_match_mode))
            
        if technical_tag is not None:
            
            _query_params.append(('technicalTag', technical_tag))
            
        if technical_tag_match_mode is not None:
            
            _query_params.append(('technicalTagMatchMode', technical_tag_match_mode))
            
        if not_in_run is not None:
            
            _query_params.append(('notInRun', not_in_run))
            
        if not_linked_to_sample is not None:
            
            _query_params.append(('notLinkedToSample', not_linked_to_sample))
            
        if instrument_run_id is not None:
            
            _query_params.append(('instrumentRunId', instrument_run_id))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/data/{dataId}/children',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_list(
        self,
        project_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        non_indexed_folders: Annotated[Optional[StrictBool], Field(description="To filter on non-indexed folders.")] = None,
        parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        owning_project_id: Annotated[Optional[List[StrictStr]], Field(description="The owning project ID to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataPagedList:
        """Retrieve the list of project data.


        :param project_id: (required)
        :type project_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: List[str]
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param non_indexed_folders: To filter on non-indexed folders.
        :type non_indexed_folders: bool
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: List[str]
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
        :type not_linked_to_sample: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param owning_project_id: The owning project ID to filter on.
        :type owning_project_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_list_serialize(
            project_id=project_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            non_indexed_folders=non_indexed_folders,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            owning_project_id=owning_project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_list_with_http_info(
        self,
        project_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        non_indexed_folders: Annotated[Optional[StrictBool], Field(description="To filter on non-indexed folders.")] = None,
        parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        owning_project_id: Annotated[Optional[List[StrictStr]], Field(description="The owning project ID to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataPagedList]:
        """Retrieve the list of project data.


        :param project_id: (required)
        :type project_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: List[str]
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param non_indexed_folders: To filter on non-indexed folders.
        :type non_indexed_folders: bool
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: List[str]
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
        :type not_linked_to_sample: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param owning_project_id: The owning project ID to filter on.
        :type owning_project_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_list_serialize(
            project_id=project_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            non_indexed_folders=non_indexed_folders,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            owning_project_id=owning_project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_list_without_preload_content(
        self,
        project_id: StrictStr,
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        non_indexed_folders: Annotated[Optional[StrictBool], Field(description="To filter on non-indexed folders.")] = None,
        parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        owning_project_id: Annotated[Optional[List[StrictStr]], Field(description="The owning project ID to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the list of project data.


        :param project_id: (required)
        :type project_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: List[str]
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param non_indexed_folders: To filter on non-indexed folders.
        :type non_indexed_folders: bool
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: List[str]
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
        :type not_linked_to_sample: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param owning_project_id: The owning project ID to filter on.
        :type owning_project_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_list_serialize(
            project_id=project_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            non_indexed_folders=non_indexed_folders,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            not_linked_to_sample=not_linked_to_sample,
            instrument_run_id=instrument_run_id,
            owning_project_id=owning_project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_list_serialize(
        self,
        project_id,
        full_text,
        id,
        filename,
        filename_match_mode,
        file_path,
        file_path_match_mode,
        status,
        format_id,
        format_code,
        type,
        non_indexed_folders,
        parent_folder_id,
        parent_folder_path,
        creation_date_after,
        creation_date_before,
        status_date_after,
        status_date_before,
        user_tag,
        user_tag_match_mode,
        run_input_tag,
        run_input_tag_match_mode,
        run_output_tag,
        run_output_tag_match_mode,
        connector_tag,
        connector_tag_match_mode,
        technical_tag,
        technical_tag_match_mode,
        not_in_run,
        not_linked_to_sample,
        instrument_run_id,
        owning_project_id,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'id': 'multi',
            'filename': 'multi',
            'filePath': 'multi',
            'status': 'multi',
            'formatId': 'multi',
            'formatCode': 'multi',
            'parentFolderId': 'multi',
            'userTag': 'multi',
            'runInputTag': 'multi',
            'runOutputTag': 'multi',
            'connectorTag': 'multi',
            'technicalTag': 'multi',
            'instrumentRunId': 'multi',
            'owningProjectId': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if full_text is not None:
            
            _query_params.append(('fullText', full_text))
            
        if id is not None:
            
            _query_params.append(('id', id))
            
        if filename is not None:
            
            _query_params.append(('filename', filename))
            
        if filename_match_mode is not None:
            
            _query_params.append(('filenameMatchMode', filename_match_mode))
            
        if file_path is not None:
            
            _query_params.append(('filePath', file_path))
            
        if file_path_match_mode is not None:
            
            _query_params.append(('filePathMatchMode', file_path_match_mode))
            
        if status is not None:
            
            _query_params.append(('status', status))
            
        if format_id is not None:
            
            _query_params.append(('formatId', format_id))
            
        if format_code is not None:
            
            _query_params.append(('formatCode', format_code))
            
        if type is not None:
            
            _query_params.append(('type', type))
            
        if non_indexed_folders is not None:
            
            _query_params.append(('nonIndexedFolders', non_indexed_folders))
            
        if parent_folder_id is not None:
            
            _query_params.append(('parentFolderId', parent_folder_id))
            
        if parent_folder_path is not None:
            
            _query_params.append(('parentFolderPath', parent_folder_path))
            
        if creation_date_after is not None:
            if isinstance(creation_date_after, datetime):
                _query_params.append(
                    (
                        'creationDateAfter',
                        creation_date_after.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('creationDateAfter', creation_date_after))
            
        if creation_date_before is not None:
            if isinstance(creation_date_before, datetime):
                _query_params.append(
                    (
                        'creationDateBefore',
                        creation_date_before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('creationDateBefore', creation_date_before))
            
        if status_date_after is not None:
            if isinstance(status_date_after, datetime):
                _query_params.append(
                    (
                        'statusDateAfter',
                        status_date_after.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('statusDateAfter', status_date_after))
            
        if status_date_before is not None:
            if isinstance(status_date_before, datetime):
                _query_params.append(
                    (
                        'statusDateBefore',
                        status_date_before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('statusDateBefore', status_date_before))
            
        if user_tag is not None:
            
            _query_params.append(('userTag', user_tag))
            
        if user_tag_match_mode is not None:
            
            _query_params.append(('userTagMatchMode', user_tag_match_mode))
            
        if run_input_tag is not None:
            
            _query_params.append(('runInputTag', run_input_tag))
            
        if run_input_tag_match_mode is not None:
            
            _query_params.append(('runInputTagMatchMode', run_input_tag_match_mode))
            
        if run_output_tag is not None:
            
            _query_params.append(('runOutputTag', run_output_tag))
            
        if run_output_tag_match_mode is not None:
            
            _query_params.append(('runOutputTagMatchMode', run_output_tag_match_mode))
            
        if connector_tag is not None:
            
            _query_params.append(('connectorTag', connector_tag))
            
        if connector_tag_match_mode is not None:
            
            _query_params.append(('connectorTagMatchMode', connector_tag_match_mode))
            
        if technical_tag is not None:
            
            _query_params.append(('technicalTag', technical_tag))
            
        if technical_tag_match_mode is not None:
            
            _query_params.append(('technicalTagMatchMode', technical_tag_match_mode))
            
        if not_in_run is not None:
            
            _query_params.append(('notInRun', not_in_run))
            
        if not_linked_to_sample is not None:
            
            _query_params.append(('notLinkedToSample', not_linked_to_sample))
            
        if instrument_run_id is not None:
            
            _query_params.append(('instrumentRunId', instrument_run_id))
            
        if owning_project_id is not None:
            
            _query_params.append(('owningProjectId', owning_project_id))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/data',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_projects_linked_to_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectList:
        """Retrieve a list of projects to which this data is linked.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_projects_linked_to_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_projects_linked_to_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectList]:
        """Retrieve a list of projects to which this data is linked.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_projects_linked_to_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_projects_linked_to_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of projects to which this data is linked.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_projects_linked_to_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_projects_linked_to_data_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/data/{dataId}/linkedProjects',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_secondary_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DataList:
        """Retrieve a list of secondary data for data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_secondary_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_secondary_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DataList]:
        """Retrieve a list of secondary data for data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_secondary_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_secondary_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of secondary data for data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_secondary_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_secondary_data_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/data/{dataId}/secondaryData',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def link_data_to_project(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectData:
        """Link data to this project.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_data_to_project_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def link_data_to_project_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectData]:
        """Link data to this project.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_data_to_project_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def link_data_to_project_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Link data to this project.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_data_to_project_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _link_data_to_project_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def remove_secondary_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        secondary_data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Remove secondary data from data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param secondary_data_id: (required)
        :type secondary_data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._remove_secondary_data_serialize(
            project_id=project_id,
            data_id=data_id,
            secondary_data_id=secondary_data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def remove_secondary_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        secondary_data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Remove secondary data from data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param secondary_data_id: (required)
        :type secondary_data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._remove_secondary_data_serialize(
            project_id=project_id,
            data_id=data_id,
            secondary_data_id=secondary_data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def remove_secondary_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        secondary_data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Remove secondary data from data.


        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param secondary_data_id: (required)
        :type secondary_data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._remove_secondary_data_serialize(
            project_id=project_id,
            data_id=data_id,
            secondary_data_id=secondary_data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _remove_secondary_data_serialize(
        self,
        project_id,
        data_id,
        secondary_data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        if secondary_data_id is not None:
            _path_params['secondaryDataId'] = secondary_data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/projects/{projectId}/data/{dataId}/secondaryData/{secondaryDataId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def schedule_download_for_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        schedule_download: ScheduleDownload,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DataTransfer:
        """Schedule a download.

        Endpoint for scheduling a download for the data specified by the ID to a connector. This download will only start when the connector is running. Data transfers for folder contents are created asynchronously, meaning that they will not be immediately visible in the project data transfers end point. Note: The localPath field is optional. When omitted or invalid, the download rules of the connector are followed.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param schedule_download: (required)
        :type schedule_download: ScheduleDownload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._schedule_download_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            schedule_download=schedule_download,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def schedule_download_for_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        schedule_download: ScheduleDownload,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DataTransfer]:
        """Schedule a download.

        Endpoint for scheduling a download for the data specified by the ID to a connector. This download will only start when the connector is running. Data transfers for folder contents are created asynchronously, meaning that they will not be immediately visible in the project data transfers end point. Note: The localPath field is optional. When omitted or invalid, the download rules of the connector are followed.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param schedule_download: (required)
        :type schedule_download: ScheduleDownload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._schedule_download_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            schedule_download=schedule_download,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def schedule_download_for_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        schedule_download: ScheduleDownload,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Schedule a download.

        Endpoint for scheduling a download for the data specified by the ID to a connector. This download will only start when the connector is running. Data transfers for folder contents are created asynchronously, meaning that they will not be immediately visible in the project data transfers end point. Note: The localPath field is optional. When omitted or invalid, the download rules of the connector are followed.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param schedule_download: (required)
        :type schedule_download: ScheduleDownload
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._schedule_download_for_data_serialize(
            project_id=project_id,
            data_id=data_id,
            schedule_download=schedule_download,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _schedule_download_for_data_serialize(
        self,
        project_id,
        data_id,
        schedule_download,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if schedule_download is not None:
            _body_params = schedule_download


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}:scheduleDownload',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unarchive_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Schedule this data for unarchival.

        Endpoint for scheduling this data for unarchival. This will also unarchive all files and directories below that data. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unarchive_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unarchive_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Schedule this data for unarchival.

        Endpoint for scheduling this data for unarchival. This will also unarchive all files and directories below that data. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unarchive_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unarchive_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Schedule this data for unarchival.

        Endpoint for scheduling this data for unarchival. This will also unarchive all files and directories below that data. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unarchive_data_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unarchive_data_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}:unarchive',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unlink_data_from_project(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Unlink data from this project.

        Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Project Data Unlinking Batch' for recursive unlinking.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_data_from_project_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unlink_data_from_project_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Unlink data from this project.

        Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Project Data Unlinking Batch' for recursive unlinking.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_data_from_project_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unlink_data_from_project_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Unlink data from this project.

        Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Project Data Unlinking Batch' for recursive unlinking.

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_data_from_project_serialize(
            project_id=project_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unlink_data_from_project_serialize(
        self,
        project_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/data/{dataId}:unlink',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_project_data(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        project_data: Annotated[ProjectData, Field(description="The updated project data.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectData:
        """Update this project data.

        Fields which can be updated for files:  - data.willBeArchivedAt  - data.willBeDeletedAt  - data.format  - data.tags  Fields which can be updated for folders:  - data.tags  

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param project_data: The updated project data. (required)
        :type project_data: ProjectData
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_data_serialize(
            project_id=project_id,
            data_id=data_id,
            project_data=project_data,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_project_data_with_http_info(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        project_data: Annotated[ProjectData, Field(description="The updated project data.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectData]:
        """Update this project data.

        Fields which can be updated for files:  - data.willBeArchivedAt  - data.willBeDeletedAt  - data.format  - data.tags  Fields which can be updated for folders:  - data.tags  

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param project_data: The updated project data. (required)
        :type project_data: ProjectData
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_data_serialize(
            project_id=project_id,
            data_id=data_id,
            project_data=project_data,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_project_data_without_preload_content(
        self,
        project_id: StrictStr,
        data_id: StrictStr,
        project_data: Annotated[ProjectData, Field(description="The updated project data.")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update this project data.

        Fields which can be updated for files:  - data.willBeArchivedAt  - data.willBeDeletedAt  - data.format  - data.tags  Fields which can be updated for folders:  - data.tags  

        :param project_id: (required)
        :type project_id: str
        :param data_id: (required)
        :type data_id: str
        :param project_data: The updated project data. (required)
        :type project_data: ProjectData
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_data_serialize(
            project_id=project_id,
            data_id=data_id,
            project_data=project_data,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectData",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_project_data_serialize(
        self,
        project_id,
        data_id,
        project_data,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if project_data is not None:
            _body_params = project_data


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/data/{dataId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def add_secondary_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
secondary_data_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def add_secondary_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    secondary_data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Add secondary data to data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param secondary_data_id: (required)
    :type secondary_data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._add_secondary_data_serialize(
        project_id=project_id,
        data_id=data_id,
        secondary_data_id=secondary_data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Add secondary data to data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param secondary_data_id: (required) :type secondary_data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def add_secondary_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
secondary_data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def add_secondary_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    secondary_data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Add secondary data to data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param secondary_data_id: (required)
    :type secondary_data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._add_secondary_data_serialize(
        project_id=project_id,
        data_id=data_id,
        secondary_data_id=secondary_data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Add secondary data to data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param secondary_data_id: (required) :type secondary_data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def add_secondary_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
secondary_data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def add_secondary_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    secondary_data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Add secondary data to data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param secondary_data_id: (required)
    :type secondary_data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._add_secondary_data_serialize(
        project_id=project_id,
        data_id=data_id,
        secondary_data_id=secondary_data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Add secondary data to data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param secondary_data_id: (required) :type secondary_data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def archive_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def archive_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Schedule this data for archival.

    Endpoint for scheduling this data for archival. This will also archive all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._archive_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Schedule this data for archival.

Endpoint for scheduling this data for archival. This will also archive all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def archive_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def archive_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Schedule this data for archival.

    Endpoint for scheduling this data for archival. This will also archive all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._archive_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Schedule this data for archival.

Endpoint for scheduling this data for archival. This will also archive all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def archive_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def archive_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Schedule this data for archival.

    Endpoint for scheduling this data for archival. This will also archive all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._archive_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Schedule this data for archival.

Endpoint for scheduling this data for archival. This will also archive all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def complete_folder_upload_session(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
folder_upload_session_id: Annotated[str, Strict(strict=True)],
complete_folder_upload_session: Annotated[CompleteFolderUploadSession, FieldInfo(annotation=NoneType, required=True, description='The info required to complete the folder upload session.')]) ‑> FolderUploadSession

Expand source code

@validate_call
def complete_folder_upload_session(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    folder_upload_session_id: StrictStr,
    complete_folder_upload_session: Annotated[CompleteFolderUploadSession, Field(description="The info required to complete the folder upload session.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> FolderUploadSession:
    """Complete a trackable folder upload session.

    Complete a trackable folder upload session. By completing the folder upload session, and specifying how many files you have uploaded, ICA can ensure that all uploaded files are accounted for.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param folder_upload_session_id: (required)
    :type folder_upload_session_id: str
    :param complete_folder_upload_session: The info required to complete the folder upload session. (required)
    :type complete_folder_upload_session: CompleteFolderUploadSession
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._complete_folder_upload_session_serialize(
        project_id=project_id,
        data_id=data_id,
        folder_upload_session_id=folder_upload_session_id,
        complete_folder_upload_session=complete_folder_upload_session,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "FolderUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Complete a trackable folder upload session.

Complete a trackable folder upload session. By completing the folder upload session, and specifying how many files you have uploaded, ICA can ensure that all uploaded files are accounted for.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param folder_upload_session_id: (required) :type folder_upload_session_id: str :param complete_folder_upload_session: The info required to complete the folder upload session. (required) :type complete_folder_upload_session: CompleteFolderUploadSession :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def complete_folder_upload_session_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
folder_upload_session_id: Annotated[str, Strict(strict=True)],
complete_folder_upload_session: Annotated[CompleteFolderUploadSession, FieldInfo(annotation=NoneType, required=True, description='The info required to complete the folder upload session.')]) ‑> ApiResponse[FolderUploadSession]

Expand source code

@validate_call
def complete_folder_upload_session_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    folder_upload_session_id: StrictStr,
    complete_folder_upload_session: Annotated[CompleteFolderUploadSession, Field(description="The info required to complete the folder upload session.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[FolderUploadSession]:
    """Complete a trackable folder upload session.

    Complete a trackable folder upload session. By completing the folder upload session, and specifying how many files you have uploaded, ICA can ensure that all uploaded files are accounted for.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param folder_upload_session_id: (required)
    :type folder_upload_session_id: str
    :param complete_folder_upload_session: The info required to complete the folder upload session. (required)
    :type complete_folder_upload_session: CompleteFolderUploadSession
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._complete_folder_upload_session_serialize(
        project_id=project_id,
        data_id=data_id,
        folder_upload_session_id=folder_upload_session_id,
        complete_folder_upload_session=complete_folder_upload_session,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "FolderUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Complete a trackable folder upload session.

Complete a trackable folder upload session. By completing the folder upload session, and specifying how many files you have uploaded, ICA can ensure that all uploaded files are accounted for.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param folder_upload_session_id: (required) :type folder_upload_session_id: str :param complete_folder_upload_session: The info required to complete the folder upload session. (required) :type complete_folder_upload_session: CompleteFolderUploadSession :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def complete_folder_upload_session_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
folder_upload_session_id: Annotated[str, Strict(strict=True)],
complete_folder_upload_session: Annotated[CompleteFolderUploadSession, FieldInfo(annotation=NoneType, required=True, description='The info required to complete the folder upload session.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def complete_folder_upload_session_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    folder_upload_session_id: StrictStr,
    complete_folder_upload_session: Annotated[CompleteFolderUploadSession, Field(description="The info required to complete the folder upload session.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Complete a trackable folder upload session.

    Complete a trackable folder upload session. By completing the folder upload session, and specifying how many files you have uploaded, ICA can ensure that all uploaded files are accounted for.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param folder_upload_session_id: (required)
    :type folder_upload_session_id: str
    :param complete_folder_upload_session: The info required to complete the folder upload session. (required)
    :type complete_folder_upload_session: CompleteFolderUploadSession
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._complete_folder_upload_session_serialize(
        project_id=project_id,
        data_id=data_id,
        folder_upload_session_id=folder_upload_session_id,
        complete_folder_upload_session=complete_folder_upload_session,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "FolderUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Complete a trackable folder upload session.

Complete a trackable folder upload session. By completing the folder upload session, and specifying how many files you have uploaded, ICA can ensure that all uploaded files are accounted for.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param folder_upload_session_id: (required) :type folder_upload_session_id: str :param complete_folder_upload_session: The info required to complete the folder upload session. (required) :type complete_folder_upload_session: CompleteFolderUploadSession :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_data_in_project(self,
project_id: Annotated[str, Strict(strict=True)],
create_data: Annotated[CreateData, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ProjectData

Expand source code

@validate_call
def create_data_in_project(
    self,
    project_id: StrictStr,
    create_data: Annotated[CreateData, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectData:
    """(Deprecated) Create data in this project.


    :param project_id: (required)
    :type project_id: str
    :param create_data: The data to create. (required)
    :type create_data: CreateData
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("POST /api/projects/{projectId}/data is deprecated.", DeprecationWarning)

    _param = self._create_data_in_project_serialize(
        project_id=project_id,
        create_data=create_data,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

(Deprecated) Create data in this project.

:param project_id: (required) :type project_id: str :param create_data: The data to create. (required) :type create_data: CreateData :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_data_in_project_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_data: Annotated[CreateData, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[ProjectData]

Expand source code

@validate_call
def create_data_in_project_with_http_info(
    self,
    project_id: StrictStr,
    create_data: Annotated[CreateData, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectData]:
    """(Deprecated) Create data in this project.


    :param project_id: (required)
    :type project_id: str
    :param create_data: The data to create. (required)
    :type create_data: CreateData
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("POST /api/projects/{projectId}/data is deprecated.", DeprecationWarning)

    _param = self._create_data_in_project_serialize(
        project_id=project_id,
        create_data=create_data,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

(Deprecated) Create data in this project.

:param project_id: (required) :type project_id: str :param create_data: The data to create. (required) :type create_data: CreateData :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_data_in_project_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_data: Annotated[CreateData, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_data_in_project_without_preload_content(
    self,
    project_id: StrictStr,
    create_data: Annotated[CreateData, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Create data in this project.


    :param project_id: (required)
    :type project_id: str
    :param create_data: The data to create. (required)
    :type create_data: CreateData
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("POST /api/projects/{projectId}/data is deprecated.", DeprecationWarning)

    _param = self._create_data_in_project_serialize(
        project_id=project_id,
        create_data=create_data,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

(Deprecated) Create data in this project.

:param project_id: (required) :type project_id: str :param create_data: The data to create. (required) :type create_data: CreateData :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_url_for_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> Download

Expand source code

@validate_call
def create_download_url_for_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Download:
    """Retrieve a download URL for this data.

    Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_url_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Download",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a download URL for this data.

Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_url_for_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[Download]

Expand source code

@validate_call
def create_download_url_for_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Download]:
    """Retrieve a download URL for this data.

    Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_url_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Download",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a download URL for this data.

Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_url_for_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_download_url_for_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a download URL for this data.

    Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_url_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Download",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a download URL for this data.

Can be used to download a file directly from the region where it is located, no connector is needed. Not applicable for Folder.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_urls_for_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id_or_path_list: DataIdOrPathList) ‑> DataUrlWithPathList

Expand source code

@validate_call
def create_download_urls_for_data(
    self,
    project_id: StrictStr,
    data_id_or_path_list: DataIdOrPathList,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DataUrlWithPathList:
    """Retrieve download URLs for the data.

    Can be used to download files directly from the region where it is located, no connector is needed. Not applicable for Folders.

    :param project_id: (required)
    :type project_id: str
    :param data_id_or_path_list: (required)
    :type data_id_or_path_list: DataIdOrPathList
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_urls_for_data_serialize(
        project_id=project_id,
        data_id_or_path_list=data_id_or_path_list,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataUrlWithPathList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve download URLs for the data.

Can be used to download files directly from the region where it is located, no connector is needed. Not applicable for Folders.

:param project_id: (required) :type project_id: str :param data_id_or_path_list: (required) :type data_id_or_path_list: DataIdOrPathList :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_urls_for_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id_or_path_list: DataIdOrPathList) ‑> ApiResponse[DataUrlWithPathList]

Expand source code

@validate_call
def create_download_urls_for_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id_or_path_list: DataIdOrPathList,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DataUrlWithPathList]:
    """Retrieve download URLs for the data.

    Can be used to download files directly from the region where it is located, no connector is needed. Not applicable for Folders.

    :param project_id: (required)
    :type project_id: str
    :param data_id_or_path_list: (required)
    :type data_id_or_path_list: DataIdOrPathList
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_urls_for_data_serialize(
        project_id=project_id,
        data_id_or_path_list=data_id_or_path_list,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataUrlWithPathList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve download URLs for the data.

Can be used to download files directly from the region where it is located, no connector is needed. Not applicable for Folders.

:param project_id: (required) :type project_id: str :param data_id_or_path_list: (required) :type data_id_or_path_list: DataIdOrPathList :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_download_urls_for_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id_or_path_list: DataIdOrPathList) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_download_urls_for_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id_or_path_list: DataIdOrPathList,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve download URLs for the data.

    Can be used to download files directly from the region where it is located, no connector is needed. Not applicable for Folders.

    :param project_id: (required)
    :type project_id: str
    :param data_id_or_path_list: (required)
    :type data_id_or_path_list: DataIdOrPathList
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_download_urls_for_data_serialize(
        project_id=project_id,
        data_id_or_path_list=data_id_or_path_list,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataUrlWithPathList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve download URLs for the data.

Can be used to download files directly from the region where it is located, no connector is needed. Not applicable for Folders.

:param project_id: (required) :type project_id: str :param data_id_or_path_list: (required) :type data_id_or_path_list: DataIdOrPathList :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_file(self,
project_id: Annotated[str, Strict(strict=True)],
create_file_data: Annotated[CreateFileData, FieldInfo(annotation=NoneType, required=True, description='The file to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ProjectData

Expand source code

@validate_call
def create_file(
    self,
    project_id: StrictStr,
    create_file_data: Annotated[CreateFileData, Field(description="The file to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectData:
    """Create a file in this project.


    :param project_id: (required)
    :type project_id: str
    :param create_file_data: The file to create. (required)
    :type create_file_data: CreateFileData
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_file_serialize(
        project_id=project_id,
        create_file_data=create_file_data,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a file in this project.

:param project_id: (required) :type project_id: str :param create_file_data: The file to create. (required) :type create_file_data: CreateFileData :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_file_data: Annotated[CreateFileData, FieldInfo(annotation=NoneType, required=True, description='The file to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[ProjectData]

Expand source code

@validate_call
def create_file_with_http_info(
    self,
    project_id: StrictStr,
    create_file_data: Annotated[CreateFileData, Field(description="The file to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectData]:
    """Create a file in this project.


    :param project_id: (required)
    :type project_id: str
    :param create_file_data: The file to create. (required)
    :type create_file_data: CreateFileData
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_file_serialize(
        project_id=project_id,
        create_file_data=create_file_data,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a file in this project.

:param project_id: (required) :type project_id: str :param create_file_data: The file to create. (required) :type create_file_data: CreateFileData :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_file_with_temporary_credentials(self,
project_id: Annotated[str, Strict(strict=True)],
create_file_and_temporary_credentials: Annotated[CreateFileAndTemporaryCredentials, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ProjectDataAndTemporaryCredentials

Expand source code

@validate_call
def create_file_with_temporary_credentials(
    self,
    project_id: StrictStr,
    create_file_and_temporary_credentials: Annotated[CreateFileAndTemporaryCredentials, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataAndTemporaryCredentials:
    """Create a file in this project, and retrieve temporary credentials for it.


    :param project_id: (required)
    :type project_id: str
    :param create_file_and_temporary_credentials: The data to create. (required)
    :type create_file_and_temporary_credentials: CreateFileAndTemporaryCredentials
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_file_with_temporary_credentials_serialize(
        project_id=project_id,
        create_file_and_temporary_credentials=create_file_and_temporary_credentials,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataAndTemporaryCredentials",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a file in this project, and retrieve temporary credentials for it.

:param project_id: (required) :type project_id: str :param create_file_and_temporary_credentials: The data to create. (required) :type create_file_and_temporary_credentials: CreateFileAndTemporaryCredentials :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_file_with_temporary_credentials_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_file_and_temporary_credentials: Annotated[CreateFileAndTemporaryCredentials, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[ProjectDataAndTemporaryCredentials]

Expand source code

@validate_call
def create_file_with_temporary_credentials_with_http_info(
    self,
    project_id: StrictStr,
    create_file_and_temporary_credentials: Annotated[CreateFileAndTemporaryCredentials, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataAndTemporaryCredentials]:
    """Create a file in this project, and retrieve temporary credentials for it.


    :param project_id: (required)
    :type project_id: str
    :param create_file_and_temporary_credentials: The data to create. (required)
    :type create_file_and_temporary_credentials: CreateFileAndTemporaryCredentials
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_file_with_temporary_credentials_serialize(
        project_id=project_id,
        create_file_and_temporary_credentials=create_file_and_temporary_credentials,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataAndTemporaryCredentials",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a file in this project, and retrieve temporary credentials for it.

:param project_id: (required) :type project_id: str :param create_file_and_temporary_credentials: The data to create. (required) :type create_file_and_temporary_credentials: CreateFileAndTemporaryCredentials :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_file_with_temporary_credentials_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_file_and_temporary_credentials: Annotated[CreateFileAndTemporaryCredentials, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_file_with_temporary_credentials_without_preload_content(
    self,
    project_id: StrictStr,
    create_file_and_temporary_credentials: Annotated[CreateFileAndTemporaryCredentials, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a file in this project, and retrieve temporary credentials for it.


    :param project_id: (required)
    :type project_id: str
    :param create_file_and_temporary_credentials: The data to create. (required)
    :type create_file_and_temporary_credentials: CreateFileAndTemporaryCredentials
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_file_with_temporary_credentials_serialize(
        project_id=project_id,
        create_file_and_temporary_credentials=create_file_and_temporary_credentials,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataAndTemporaryCredentials",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a file in this project, and retrieve temporary credentials for it.

:param project_id: (required) :type project_id: str :param create_file_and_temporary_credentials: The data to create. (required) :type create_file_and_temporary_credentials: CreateFileAndTemporaryCredentials :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_file_with_upload_url(self,
project_id: Annotated[str, Strict(strict=True)],
create_file_and_upload_url: Annotated[CreateFileAndUploadUrl, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ProjectFileAndUploadUrl

Expand source code

@validate_call
def create_file_with_upload_url(
    self,
    project_id: StrictStr,
    create_file_and_upload_url: Annotated[CreateFileAndUploadUrl, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectFileAndUploadUrl:
    """Create a file in this project, and retrieve an upload url for it.


    :param project_id: (required)
    :type project_id: str
    :param create_file_and_upload_url: The data to create. (required)
    :type create_file_and_upload_url: CreateFileAndUploadUrl
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_file_with_upload_url_serialize(
        project_id=project_id,
        create_file_and_upload_url=create_file_and_upload_url,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectFileAndUploadUrl",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a file in this project, and retrieve an upload url for it.

:param project_id: (required) :type project_id: str :param create_file_and_upload_url: The data to create. (required) :type create_file_and_upload_url: CreateFileAndUploadUrl :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_file_with_upload_url_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_file_and_upload_url: Annotated[CreateFileAndUploadUrl, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[ProjectFileAndUploadUrl]

Expand source code

@validate_call
def create_file_with_upload_url_with_http_info(
    self,
    project_id: StrictStr,
    create_file_and_upload_url: Annotated[CreateFileAndUploadUrl, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectFileAndUploadUrl]:
    """Create a file in this project, and retrieve an upload url for it.


    :param project_id: (required)
    :type project_id: str
    :param create_file_and_upload_url: The data to create. (required)
    :type create_file_and_upload_url: CreateFileAndUploadUrl
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_file_with_upload_url_serialize(
        project_id=project_id,
        create_file_and_upload_url=create_file_and_upload_url,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectFileAndUploadUrl",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a file in this project, and retrieve an upload url for it.

:param project_id: (required) :type project_id: str :param create_file_and_upload_url: The data to create. (required) :type create_file_and_upload_url: CreateFileAndUploadUrl :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_file_with_upload_url_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_file_and_upload_url: Annotated[CreateFileAndUploadUrl, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_file_with_upload_url_without_preload_content(
    self,
    project_id: StrictStr,
    create_file_and_upload_url: Annotated[CreateFileAndUploadUrl, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a file in this project, and retrieve an upload url for it.


    :param project_id: (required)
    :type project_id: str
    :param create_file_and_upload_url: The data to create. (required)
    :type create_file_and_upload_url: CreateFileAndUploadUrl
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_file_with_upload_url_serialize(
        project_id=project_id,
        create_file_and_upload_url=create_file_and_upload_url,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectFileAndUploadUrl",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a file in this project, and retrieve an upload url for it.

:param project_id: (required) :type project_id: str :param create_file_and_upload_url: The data to create. (required) :type create_file_and_upload_url: CreateFileAndUploadUrl :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_file_data: Annotated[CreateFileData, FieldInfo(annotation=NoneType, required=True, description='The file to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_file_without_preload_content(
    self,
    project_id: StrictStr,
    create_file_data: Annotated[CreateFileData, Field(description="The file to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a file in this project.


    :param project_id: (required)
    :type project_id: str
    :param create_file_data: The file to create. (required)
    :type create_file_data: CreateFileData
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_file_serialize(
        project_id=project_id,
        create_file_data=create_file_data,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a file in this project.

:param project_id: (required) :type project_id: str :param create_file_data: The file to create. (required) :type create_file_data: CreateFileData :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder(self,
project_id: Annotated[str, Strict(strict=True)],
create_folder: Annotated[CreateFolder, FieldInfo(annotation=NoneType, required=True, description='The folder to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ProjectData

Expand source code

@validate_call
def create_folder(
    self,
    project_id: StrictStr,
    create_folder: Annotated[CreateFolder, Field(description="The folder to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectData:
    """Create a folder in this project.


    :param project_id: (required)
    :type project_id: str
    :param create_folder: The folder to create. (required)
    :type create_folder: CreateFolder
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_serialize(
        project_id=project_id,
        create_folder=create_folder,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a folder in this project.

:param project_id: (required) :type project_id: str :param create_folder: The folder to create. (required) :type create_folder: CreateFolder :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_upload_session(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
create_temporary_credentials: Annotated[CreateTemporaryCredentials | None, FieldInfo(annotation=NoneType, required=True, description='Temporary credentials request options.')] = None) ‑> FolderUploadSession

Expand source code

@validate_call
def create_folder_upload_session(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> FolderUploadSession:
    """Create a trackable folder upload session.

    This endpoint can be used to ensure that all uploaded files within the requested session are accounted for. This call has to be used together with the :complete endpoint once upload is done.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param create_temporary_credentials: Temporary credentials request options.
    :type create_temporary_credentials: CreateTemporaryCredentials
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_upload_session_serialize(
        project_id=project_id,
        data_id=data_id,
        create_temporary_credentials=create_temporary_credentials,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "FolderUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a trackable folder upload session.

This endpoint can be used to ensure that all uploaded files within the requested session are accounted for. This call has to be used together with the :complete endpoint once upload is done.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param create_temporary_credentials: Temporary credentials request options. :type create_temporary_credentials: CreateTemporaryCredentials :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_upload_session_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
create_temporary_credentials: Annotated[CreateTemporaryCredentials | None, FieldInfo(annotation=NoneType, required=True, description='Temporary credentials request options.')] = None) ‑> ApiResponse[FolderUploadSession]

Expand source code

@validate_call
def create_folder_upload_session_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[FolderUploadSession]:
    """Create a trackable folder upload session.

    This endpoint can be used to ensure that all uploaded files within the requested session are accounted for. This call has to be used together with the :complete endpoint once upload is done.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param create_temporary_credentials: Temporary credentials request options.
    :type create_temporary_credentials: CreateTemporaryCredentials
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_upload_session_serialize(
        project_id=project_id,
        data_id=data_id,
        create_temporary_credentials=create_temporary_credentials,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "FolderUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a trackable folder upload session.

This endpoint can be used to ensure that all uploaded files within the requested session are accounted for. This call has to be used together with the :complete endpoint once upload is done.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param create_temporary_credentials: Temporary credentials request options. :type create_temporary_credentials: CreateTemporaryCredentials :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_upload_session_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
create_temporary_credentials: Annotated[CreateTemporaryCredentials | None, FieldInfo(annotation=NoneType, required=True, description='Temporary credentials request options.')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_folder_upload_session_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a trackable folder upload session.

    This endpoint can be used to ensure that all uploaded files within the requested session are accounted for. This call has to be used together with the :complete endpoint once upload is done.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param create_temporary_credentials: Temporary credentials request options.
    :type create_temporary_credentials: CreateTemporaryCredentials
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_upload_session_serialize(
        project_id=project_id,
        data_id=data_id,
        create_temporary_credentials=create_temporary_credentials,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "FolderUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a trackable folder upload session.

This endpoint can be used to ensure that all uploaded files within the requested session are accounted for. This call has to be used together with the :complete endpoint once upload is done.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param create_temporary_credentials: Temporary credentials request options. :type create_temporary_credentials: CreateTemporaryCredentials :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_folder: Annotated[CreateFolder, FieldInfo(annotation=NoneType, required=True, description='The folder to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[ProjectData]

Expand source code

@validate_call
def create_folder_with_http_info(
    self,
    project_id: StrictStr,
    create_folder: Annotated[CreateFolder, Field(description="The folder to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectData]:
    """Create a folder in this project.


    :param project_id: (required)
    :type project_id: str
    :param create_folder: The folder to create. (required)
    :type create_folder: CreateFolder
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_serialize(
        project_id=project_id,
        create_folder=create_folder,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a folder in this project.

:param project_id: (required) :type project_id: str :param create_folder: The folder to create. (required) :type create_folder: CreateFolder :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_with_temporary_credentials(self,
project_id: Annotated[str, Strict(strict=True)],
create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ProjectDataAndTemporaryCredentials

Expand source code

@validate_call
def create_folder_with_temporary_credentials(
    self,
    project_id: StrictStr,
    create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataAndTemporaryCredentials:
    """Create a folder in this project, and and retrieve temporary credentials for it.


    :param project_id: (required)
    :type project_id: str
    :param create_folder_and_temporary_credentials: The data to create. (required)
    :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_with_temporary_credentials_serialize(
        project_id=project_id,
        create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataAndTemporaryCredentials",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a folder in this project, and and retrieve temporary credentials for it.

:param project_id: (required) :type project_id: str :param create_folder_and_temporary_credentials: The data to create. (required) :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_with_temporary_credentials_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[ProjectDataAndTemporaryCredentials]

Expand source code

@validate_call
def create_folder_with_temporary_credentials_with_http_info(
    self,
    project_id: StrictStr,
    create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataAndTemporaryCredentials]:
    """Create a folder in this project, and and retrieve temporary credentials for it.


    :param project_id: (required)
    :type project_id: str
    :param create_folder_and_temporary_credentials: The data to create. (required)
    :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_with_temporary_credentials_serialize(
        project_id=project_id,
        create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataAndTemporaryCredentials",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a folder in this project, and and retrieve temporary credentials for it.

:param project_id: (required) :type project_id: str :param create_folder_and_temporary_credentials: The data to create. (required) :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_with_temporary_credentials_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_folder_with_temporary_credentials_without_preload_content(
    self,
    project_id: StrictStr,
    create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a folder in this project, and and retrieve temporary credentials for it.


    :param project_id: (required)
    :type project_id: str
    :param create_folder_and_temporary_credentials: The data to create. (required)
    :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_with_temporary_credentials_serialize(
        project_id=project_id,
        create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataAndTemporaryCredentials",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a folder in this project, and and retrieve temporary credentials for it.

:param project_id: (required) :type project_id: str :param create_folder_and_temporary_credentials: The data to create. (required) :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_with_upload_session(self,
project_id: Annotated[str, Strict(strict=True)],
create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ProjectFolderAndUploadSession

Expand source code

@validate_call
def create_folder_with_upload_session(
    self,
    project_id: StrictStr,
    create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectFolderAndUploadSession:
    """Create a folder in this project, and create a trackable folder upload session.


    :param project_id: (required)
    :type project_id: str
    :param create_folder_and_temporary_credentials: The data to create. (required)
    :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_with_upload_session_serialize(
        project_id=project_id,
        create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectFolderAndUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a folder in this project, and create a trackable folder upload session.

:param project_id: (required) :type project_id: str :param create_folder_and_temporary_credentials: The data to create. (required) :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_with_upload_session_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[ProjectFolderAndUploadSession]

Expand source code

@validate_call
def create_folder_with_upload_session_with_http_info(
    self,
    project_id: StrictStr,
    create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectFolderAndUploadSession]:
    """Create a folder in this project, and create a trackable folder upload session.


    :param project_id: (required)
    :type project_id: str
    :param create_folder_and_temporary_credentials: The data to create. (required)
    :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_with_upload_session_serialize(
        project_id=project_id,
        create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectFolderAndUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a folder in this project, and create a trackable folder upload session.

:param project_id: (required) :type project_id: str :param create_folder_and_temporary_credentials: The data to create. (required) :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_with_upload_session_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, FieldInfo(annotation=NoneType, required=True, description='The data to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_folder_with_upload_session_without_preload_content(
    self,
    project_id: StrictStr,
    create_folder_and_temporary_credentials: Annotated[CreateFolderAndTemporaryCredentials, Field(description="The data to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a folder in this project, and create a trackable folder upload session.


    :param project_id: (required)
    :type project_id: str
    :param create_folder_and_temporary_credentials: The data to create. (required)
    :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_with_upload_session_serialize(
        project_id=project_id,
        create_folder_and_temporary_credentials=create_folder_and_temporary_credentials,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectFolderAndUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a folder in this project, and create a trackable folder upload session.

:param project_id: (required) :type project_id: str :param create_folder_and_temporary_credentials: The data to create. (required) :type create_folder_and_temporary_credentials: CreateFolderAndTemporaryCredentials :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_folder_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_folder: Annotated[CreateFolder, FieldInfo(annotation=NoneType, required=True, description='The folder to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_folder_without_preload_content(
    self,
    project_id: StrictStr,
    create_folder: Annotated[CreateFolder, Field(description="The folder to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a folder in this project.


    :param project_id: (required)
    :type project_id: str
    :param create_folder: The folder to create. (required)
    :type create_folder: CreateFolder
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_folder_serialize(
        project_id=project_id,
        create_folder=create_folder,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a folder in this project.

:param project_id: (required) :type project_id: str :param create_folder: The folder to create. (required) :type create_folder: CreateFolder :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_inline_view_url_for_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> InlineView

Expand source code

@validate_call
def create_inline_view_url_for_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> InlineView:
    """Retrieve an URL for this data to use for inline view in a browser.

    Can be used to view a file directly from the region where it is located, no connector is needed.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_inline_view_url_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InlineView",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve an URL for this data to use for inline view in a browser.

Can be used to view a file directly from the region where it is located, no connector is needed.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_inline_view_url_for_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[InlineView]

Expand source code

@validate_call
def create_inline_view_url_for_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[InlineView]:
    """Retrieve an URL for this data to use for inline view in a browser.

    Can be used to view a file directly from the region where it is located, no connector is needed.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_inline_view_url_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InlineView",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve an URL for this data to use for inline view in a browser.

Can be used to view a file directly from the region where it is located, no connector is needed.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_inline_view_url_for_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_inline_view_url_for_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve an URL for this data to use for inline view in a browser.

    Can be used to view a file directly from the region where it is located, no connector is needed.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_inline_view_url_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InlineView",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve an URL for this data to use for inline view in a browser.

Can be used to view a file directly from the region where it is located, no connector is needed.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_non_indexed_folder(self,
project_id: Annotated[str, Strict(strict=True)],
create_non_indexed_folder: Annotated[CreateNonIndexedFolder, FieldInfo(annotation=NoneType, required=True, description='The non indexed folder to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ProjectData

Expand source code

@validate_call
def create_non_indexed_folder(
    self,
    project_id: StrictStr,
    create_non_indexed_folder: Annotated[CreateNonIndexedFolder, Field(description="The non indexed folder to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectData:
    """Create a non indexed folder in this project. The folder will be created as a top-level folder.


    :param project_id: (required)
    :type project_id: str
    :param create_non_indexed_folder: The non indexed folder to create. (required)
    :type create_non_indexed_folder: CreateNonIndexedFolder
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_non_indexed_folder_serialize(
        project_id=project_id,
        create_non_indexed_folder=create_non_indexed_folder,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a non indexed folder in this project. The folder will be created as a top-level folder.

:param project_id: (required) :type project_id: str :param create_non_indexed_folder: The non indexed folder to create. (required) :type create_non_indexed_folder: CreateNonIndexedFolder :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_non_indexed_folder_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_non_indexed_folder: Annotated[CreateNonIndexedFolder, FieldInfo(annotation=NoneType, required=True, description='The non indexed folder to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[ProjectData]

Expand source code

@validate_call
def create_non_indexed_folder_with_http_info(
    self,
    project_id: StrictStr,
    create_non_indexed_folder: Annotated[CreateNonIndexedFolder, Field(description="The non indexed folder to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectData]:
    """Create a non indexed folder in this project. The folder will be created as a top-level folder.


    :param project_id: (required)
    :type project_id: str
    :param create_non_indexed_folder: The non indexed folder to create. (required)
    :type create_non_indexed_folder: CreateNonIndexedFolder
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_non_indexed_folder_serialize(
        project_id=project_id,
        create_non_indexed_folder=create_non_indexed_folder,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a non indexed folder in this project. The folder will be created as a top-level folder.

:param project_id: (required) :type project_id: str :param create_non_indexed_folder: The non indexed folder to create. (required) :type create_non_indexed_folder: CreateNonIndexedFolder :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_non_indexed_folder_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_non_indexed_folder: Annotated[CreateNonIndexedFolder, FieldInfo(annotation=NoneType, required=True, description='The non indexed folder to create.')],
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_non_indexed_folder_without_preload_content(
    self,
    project_id: StrictStr,
    create_non_indexed_folder: Annotated[CreateNonIndexedFolder, Field(description="The non indexed folder to create.")],
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a non indexed folder in this project. The folder will be created as a top-level folder.


    :param project_id: (required)
    :type project_id: str
    :param create_non_indexed_folder: The non indexed folder to create. (required)
    :type create_non_indexed_folder: CreateNonIndexedFolder
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_non_indexed_folder_serialize(
        project_id=project_id,
        create_non_indexed_folder=create_non_indexed_folder,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a non indexed folder in this project. The folder will be created as a top-level folder.

:param project_id: (required) :type project_id: str :param create_non_indexed_folder: The non indexed folder to create. (required) :type create_non_indexed_folder: CreateNonIndexedFolder :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_temporary_credentials_for_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
create_temporary_credentials: Annotated[CreateTemporaryCredentials | None, FieldInfo(annotation=NoneType, required=True, description='Temporary credentials request options.')] = None) ‑> TempCredentials

Expand source code

@validate_call
def create_temporary_credentials_for_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> TempCredentials:
    """Retrieve temporary credentials for this data.

    Can be used to upload or download a file directly from the region where it is located, no connector is needed. The returned credentials expire after 36 hours.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param create_temporary_credentials: Temporary credentials request options.
    :type create_temporary_credentials: CreateTemporaryCredentials
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_temporary_credentials_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        create_temporary_credentials=create_temporary_credentials,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TempCredentials",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve temporary credentials for this data.

Can be used to upload or download a file directly from the region where it is located, no connector is needed. The returned credentials expire after 36 hours.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param create_temporary_credentials: Temporary credentials request options. :type create_temporary_credentials: CreateTemporaryCredentials :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_temporary_credentials_for_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
create_temporary_credentials: Annotated[CreateTemporaryCredentials | None, FieldInfo(annotation=NoneType, required=True, description='Temporary credentials request options.')] = None) ‑> ApiResponse[TempCredentials]

Expand source code

@validate_call
def create_temporary_credentials_for_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[TempCredentials]:
    """Retrieve temporary credentials for this data.

    Can be used to upload or download a file directly from the region where it is located, no connector is needed. The returned credentials expire after 36 hours.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param create_temporary_credentials: Temporary credentials request options.
    :type create_temporary_credentials: CreateTemporaryCredentials
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_temporary_credentials_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        create_temporary_credentials=create_temporary_credentials,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TempCredentials",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve temporary credentials for this data.

Can be used to upload or download a file directly from the region where it is located, no connector is needed. The returned credentials expire after 36 hours.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param create_temporary_credentials: Temporary credentials request options. :type create_temporary_credentials: CreateTemporaryCredentials :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_temporary_credentials_for_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
create_temporary_credentials: Annotated[CreateTemporaryCredentials | None, FieldInfo(annotation=NoneType, required=True, description='Temporary credentials request options.')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_temporary_credentials_for_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    create_temporary_credentials: Annotated[Optional[CreateTemporaryCredentials], Field(description="Temporary credentials request options.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve temporary credentials for this data.

    Can be used to upload or download a file directly from the region where it is located, no connector is needed. The returned credentials expire after 36 hours.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param create_temporary_credentials: Temporary credentials request options.
    :type create_temporary_credentials: CreateTemporaryCredentials
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_temporary_credentials_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        create_temporary_credentials=create_temporary_credentials,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "TempCredentials",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve temporary credentials for this data.

Can be used to upload or download a file directly from the region where it is located, no connector is needed. The returned credentials expire after 36 hours.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param create_temporary_credentials: Temporary credentials request options. :type create_temporary_credentials: CreateTemporaryCredentials :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_upload_url_for_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
file_type: Annotated[str, Strict(strict=True)] | None = None,
hash: Annotated[str, Strict(strict=True)] | None = None) ‑> Upload

Expand source code

@validate_call
def create_upload_url_for_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    file_type: Optional[StrictStr] = None,
    hash: Optional[StrictStr] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Upload:
    """Retrieve an upload URL for this data.

    Can be used to upload a file directly from the region where it is located, no connector is needed. The project identifier must match the project which owns the data. You can create both new files and overwrite files in status 'partial'.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param file_type:
    :type file_type: str
    :param hash:
    :type hash: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_upload_url_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        file_type=file_type,
        hash=hash,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Upload",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve an upload URL for this data.

Can be used to upload a file directly from the region where it is located, no connector is needed. The project identifier must match the project which owns the data. You can create both new files and overwrite files in status 'partial'.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param file_type: :type file_type: str :param hash: :type hash: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_upload_url_for_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
file_type: Annotated[str, Strict(strict=True)] | None = None,
hash: Annotated[str, Strict(strict=True)] | None = None) ‑> ApiResponse[Upload]

Expand source code

@validate_call
def create_upload_url_for_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    file_type: Optional[StrictStr] = None,
    hash: Optional[StrictStr] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Upload]:
    """Retrieve an upload URL for this data.

    Can be used to upload a file directly from the region where it is located, no connector is needed. The project identifier must match the project which owns the data. You can create both new files and overwrite files in status 'partial'.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param file_type:
    :type file_type: str
    :param hash:
    :type hash: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_upload_url_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        file_type=file_type,
        hash=hash,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Upload",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve an upload URL for this data.

Can be used to upload a file directly from the region where it is located, no connector is needed. The project identifier must match the project which owns the data. You can create both new files and overwrite files in status 'partial'.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param file_type: :type file_type: str :param hash: :type hash: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_upload_url_for_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
file_type: Annotated[str, Strict(strict=True)] | None = None,
hash: Annotated[str, Strict(strict=True)] | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_upload_url_for_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    file_type: Optional[StrictStr] = None,
    hash: Optional[StrictStr] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve an upload URL for this data.

    Can be used to upload a file directly from the region where it is located, no connector is needed. The project identifier must match the project which owns the data. You can create both new files and overwrite files in status 'partial'.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param file_type:
    :type file_type: str
    :param hash:
    :type hash: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_upload_url_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        file_type=file_type,
        hash=hash,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Upload",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve an upload URL for this data.

Can be used to upload a file directly from the region where it is located, no connector is needed. The project identifier must match the project which owns the data. You can create both new files and overwrite files in status 'partial'.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param file_type: :type file_type: str :param hash: :type hash: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def delete_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Schedule this data for deletion.

    Endpoint for scheduling this data for deletion. This will also delete all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Schedule this data for deletion.

Endpoint for scheduling this data for deletion. This will also delete all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Schedule this data for deletion.

    Endpoint for scheduling this data for deletion. This will also delete all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Schedule this data for deletion.

Endpoint for scheduling this data for deletion. This will also delete all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Schedule this data for deletion.

    Endpoint for scheduling this data for deletion. This will also delete all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Schedule this data for deletion.

Endpoint for scheduling this data for deletion. This will also delete all files and directories below that data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_eligible_for_linking(self,
project_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
file_path: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
parent_folder_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> DataPagedList

Expand source code

@validate_call
def get_data_eligible_for_linking(
    self,
    project_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DataPagedList:
    """Retrieve a list of data eligible for linking to the current project.


    :param project_id: (required)
    :type project_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: List[str]
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: List[str]
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.
    :type not_linked_to_sample: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_eligible_for_linking_serialize(
        project_id=project_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of data eligible for linking to the current project.

:param project_id: (required) :type project_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: List[str] :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: List[str] :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_eligible_for_linking_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
file_path: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
parent_folder_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> ApiResponse[DataPagedList]

Expand source code

@validate_call
def get_data_eligible_for_linking_with_http_info(
    self,
    project_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DataPagedList]:
    """Retrieve a list of data eligible for linking to the current project.


    :param project_id: (required)
    :type project_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: List[str]
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: List[str]
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.
    :type not_linked_to_sample: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_eligible_for_linking_serialize(
        project_id=project_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of data eligible for linking to the current project.

:param project_id: (required) :type project_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: List[str] :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: List[str] :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_eligible_for_linking_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
file_path: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
parent_folder_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_data_eligible_for_linking_without_preload_content(
    self,
    project_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of data eligible for linking to the current project.


    :param project_id: (required)
    :type project_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: List[str]
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: List[str]
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.
    :type not_linked_to_sample: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_eligible_for_linking_serialize(
        project_id=project_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of data eligible for linking to the current project.

:param project_id: (required) :type project_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: List[str] :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: List[str] :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_folder_upload_session(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
folder_upload_session_id: Annotated[str, Strict(strict=True)]) ‑> FolderUploadSession

Expand source code

@validate_call
def get_folder_upload_session(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    folder_upload_session_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> FolderUploadSession:
    """Retrieve folder upload session details.

    Retrieve folder upload session details, including the current status of your upload session.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param folder_upload_session_id: (required)
    :type folder_upload_session_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_folder_upload_session_serialize(
        project_id=project_id,
        data_id=data_id,
        folder_upload_session_id=folder_upload_session_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "FolderUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve folder upload session details.

Retrieve folder upload session details, including the current status of your upload session.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param folder_upload_session_id: (required) :type folder_upload_session_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_folder_upload_session_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
folder_upload_session_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[FolderUploadSession]

Expand source code

@validate_call
def get_folder_upload_session_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    folder_upload_session_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[FolderUploadSession]:
    """Retrieve folder upload session details.

    Retrieve folder upload session details, including the current status of your upload session.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param folder_upload_session_id: (required)
    :type folder_upload_session_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_folder_upload_session_serialize(
        project_id=project_id,
        data_id=data_id,
        folder_upload_session_id=folder_upload_session_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "FolderUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve folder upload session details.

Retrieve folder upload session details, including the current status of your upload session.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param folder_upload_session_id: (required) :type folder_upload_session_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_folder_upload_session_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
folder_upload_session_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_folder_upload_session_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    folder_upload_session_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve folder upload session details.

    Retrieve folder upload session details, including the current status of your upload session.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param folder_upload_session_id: (required)
    :type folder_upload_session_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_folder_upload_session_serialize(
        project_id=project_id,
        data_id=data_id,
        folder_upload_session_id=folder_upload_session_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "FolderUploadSession",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve folder upload session details.

Retrieve folder upload session details, including the current status of your upload session.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param folder_upload_session_id: (required) :type folder_upload_session_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_non_sample_project_data(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ProjectDataPagedList

Expand source code

@validate_call
def get_non_sample_project_data(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataPagedList:
    """Retrieve a list of project data not linked to a sample.


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_non_sample_project_data_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of project data not linked to a sample.

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_non_sample_project_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ApiResponse[ProjectDataPagedList]

Expand source code

@validate_call
def get_non_sample_project_data_with_http_info(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataPagedList]:
    """Retrieve a list of project data not linked to a sample.


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_non_sample_project_data_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of project data not linked to a sample.

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_non_sample_project_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_non_sample_project_data_without_preload_content(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of project data not linked to a sample.


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_non_sample_project_data_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of project data not linked to a sample.

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ProjectData

Expand source code

@validate_call
def get_project_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectData:
    """Retrieve a project data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_children(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ProjectDataPagedList

Expand source code

@validate_call
def get_project_data_children(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataPagedList:
    """Retrieve the children of this data.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added pagination 

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
    :type not_linked_to_sample: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_children_serialize(
        project_id=project_id,
        data_id=data_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the children of this data.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added pagination

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_children_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ApiResponse[ProjectDataPagedList]

Expand source code

@validate_call
def get_project_data_children_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataPagedList]:
    """Retrieve the children of this data.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added pagination 

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
    :type not_linked_to_sample: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_children_serialize(
        project_id=project_id,
        data_id=data_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the children of this data.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added pagination

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_children_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_children_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the children of this data.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added pagination 

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
    :type not_linked_to_sample: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_children_serialize(
        project_id=project_id,
        data_id=data_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the children of this data.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added pagination

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_list(self,
project_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
file_path: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
non_indexed_folders: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To filter on non-indexed folders.')] = None,
parent_folder_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
owning_project_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The owning project ID to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> ProjectDataPagedList

Expand source code

@validate_call
def get_project_data_list(
    self,
    project_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    non_indexed_folders: Annotated[Optional[StrictBool], Field(description="To filter on non-indexed folders.")] = None,
    parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    owning_project_id: Annotated[Optional[List[StrictStr]], Field(description="The owning project ID to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataPagedList:
    """Retrieve the list of project data.


    :param project_id: (required)
    :type project_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: List[str]
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param non_indexed_folders: To filter on non-indexed folders.
    :type non_indexed_folders: bool
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: List[str]
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
    :type not_linked_to_sample: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param owning_project_id: The owning project ID to filter on.
    :type owning_project_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_list_serialize(
        project_id=project_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        non_indexed_folders=non_indexed_folders,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        owning_project_id=owning_project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the list of project data.

:param project_id: (required) :type project_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: List[str] :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param non_indexed_folders: To filter on non-indexed folders. :type non_indexed_folders: bool :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: List[str] :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param owning_project_id: The owning project ID to filter on. :type owning_project_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_list_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
file_path: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
non_indexed_folders: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To filter on non-indexed folders.')] = None,
parent_folder_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
owning_project_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The owning project ID to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> ApiResponse[ProjectDataPagedList]

Expand source code

@validate_call
def get_project_data_list_with_http_info(
    self,
    project_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    non_indexed_folders: Annotated[Optional[StrictBool], Field(description="To filter on non-indexed folders.")] = None,
    parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    owning_project_id: Annotated[Optional[List[StrictStr]], Field(description="The owning project ID to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataPagedList]:
    """Retrieve the list of project data.


    :param project_id: (required)
    :type project_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: List[str]
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param non_indexed_folders: To filter on non-indexed folders.
    :type non_indexed_folders: bool
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: List[str]
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
    :type not_linked_to_sample: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param owning_project_id: The owning project ID to filter on.
    :type owning_project_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_list_serialize(
        project_id=project_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        non_indexed_folders=non_indexed_folders,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        owning_project_id=owning_project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the list of project data.

:param project_id: (required) :type project_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: List[str] :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param non_indexed_folders: To filter on non-indexed folders. :type non_indexed_folders: bool :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: List[str] :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param owning_project_id: The owning project ID to filter on. :type owning_project_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_list_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
file_path: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
non_indexed_folders: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To filter on non-indexed folders.')] = None,
parent_folder_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
not_linked_to_sample: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
owning_project_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The owning project ID to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_list_without_preload_content(
    self,
    project_id: StrictStr,
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    non_indexed_folders: Annotated[Optional[StrictBool], Field(description="To filter on non-indexed folders.")] = None,
    parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    not_linked_to_sample: Annotated[Optional[StrictBool], Field(description="When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    owning_project_id: Annotated[Optional[List[StrictStr]], Field(description="The owning project ID to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the list of project data.


    :param project_id: (required)
    :type project_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: List[str]
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param non_indexed_folders: To filter on non-indexed folders.
    :type non_indexed_folders: bool
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: List[str]
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned.  This filter implies a filter of type File.
    :type not_linked_to_sample: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param owning_project_id: The owning project ID to filter on.
    :type owning_project_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_list_serialize(
        project_id=project_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        non_indexed_folders=non_indexed_folders,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        not_linked_to_sample=not_linked_to_sample,
        instrument_run_id=instrument_run_id,
        owning_project_id=owning_project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the list of project data.

:param project_id: (required) :type project_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: List[str] :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param non_indexed_folders: To filter on non-indexed folders. :type non_indexed_folders: bool :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: List[str] :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param not_linked_to_sample: When set to true only data that is unlinked to a sample will be returned. This filter implies a filter of type File. :type not_linked_to_sample: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param owning_project_id: The owning project ID to filter on. :type owning_project_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectData]

Expand source code

@validate_call
def get_project_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectData]:
    """Retrieve a project data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_projects_linked_to_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ProjectList

Expand source code

@validate_call
def get_projects_linked_to_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectList:
    """Retrieve a list of projects to which this data is linked.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_projects_linked_to_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of projects to which this data is linked.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_projects_linked_to_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectList]

Expand source code

@validate_call
def get_projects_linked_to_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectList]:
    """Retrieve a list of projects to which this data is linked.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_projects_linked_to_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of projects to which this data is linked.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_projects_linked_to_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_projects_linked_to_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of projects to which this data is linked.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_projects_linked_to_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of projects to which this data is linked.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_secondary_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> DataList

Expand source code

@validate_call
def get_secondary_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DataList:
    """Retrieve a list of secondary data for data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_secondary_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of secondary data for data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_secondary_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[DataList]

Expand source code

@validate_call
def get_secondary_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DataList]:
    """Retrieve a list of secondary data for data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_secondary_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of secondary data for data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_secondary_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_secondary_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of secondary data for data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_secondary_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of secondary data for data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_data_to_project(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ProjectData

Expand source code

@validate_call
def link_data_to_project(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectData:
    """Link data to this project.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_data_to_project_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Link data to this project.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_data_to_project_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectData]

Expand source code

@validate_call
def link_data_to_project_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectData]:
    """Link data to this project.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_data_to_project_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Link data to this project.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_data_to_project_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def link_data_to_project_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Link data to this project.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_data_to_project_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Link data to this project.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def remove_secondary_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
secondary_data_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def remove_secondary_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    secondary_data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Remove secondary data from data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param secondary_data_id: (required)
    :type secondary_data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._remove_secondary_data_serialize(
        project_id=project_id,
        data_id=data_id,
        secondary_data_id=secondary_data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Remove secondary data from data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param secondary_data_id: (required) :type secondary_data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def remove_secondary_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
secondary_data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def remove_secondary_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    secondary_data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Remove secondary data from data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param secondary_data_id: (required)
    :type secondary_data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._remove_secondary_data_serialize(
        project_id=project_id,
        data_id=data_id,
        secondary_data_id=secondary_data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Remove secondary data from data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param secondary_data_id: (required) :type secondary_data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def remove_secondary_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
secondary_data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def remove_secondary_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    secondary_data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Remove secondary data from data.


    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param secondary_data_id: (required)
    :type secondary_data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._remove_secondary_data_serialize(
        project_id=project_id,
        data_id=data_id,
        secondary_data_id=secondary_data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Remove secondary data from data.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param secondary_data_id: (required) :type secondary_data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def schedule_download_for_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
schedule_download: ScheduleDownload) ‑> DataTransfer

Expand source code

@validate_call
def schedule_download_for_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    schedule_download: ScheduleDownload,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DataTransfer:
    """Schedule a download.

    Endpoint for scheduling a download for the data specified by the ID to a connector. This download will only start when the connector is running. Data transfers for folder contents are created asynchronously, meaning that they will not be immediately visible in the project data transfers end point. Note: The localPath field is optional. When omitted or invalid, the download rules of the connector are followed.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param schedule_download: (required)
    :type schedule_download: ScheduleDownload
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._schedule_download_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        schedule_download=schedule_download,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Schedule a download.

Endpoint for scheduling a download for the data specified by the ID to a connector. This download will only start when the connector is running. Data transfers for folder contents are created asynchronously, meaning that they will not be immediately visible in the project data transfers end point. Note: The localPath field is optional. When omitted or invalid, the download rules of the connector are followed.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param schedule_download: (required) :type schedule_download: ScheduleDownload :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def schedule_download_for_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
schedule_download: ScheduleDownload) ‑> ApiResponse[DataTransfer]

Expand source code

@validate_call
def schedule_download_for_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    schedule_download: ScheduleDownload,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DataTransfer]:
    """Schedule a download.

    Endpoint for scheduling a download for the data specified by the ID to a connector. This download will only start when the connector is running. Data transfers for folder contents are created asynchronously, meaning that they will not be immediately visible in the project data transfers end point. Note: The localPath field is optional. When omitted or invalid, the download rules of the connector are followed.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param schedule_download: (required)
    :type schedule_download: ScheduleDownload
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._schedule_download_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        schedule_download=schedule_download,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Schedule a download.

Endpoint for scheduling a download for the data specified by the ID to a connector. This download will only start when the connector is running. Data transfers for folder contents are created asynchronously, meaning that they will not be immediately visible in the project data transfers end point. Note: The localPath field is optional. When omitted or invalid, the download rules of the connector are followed.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param schedule_download: (required) :type schedule_download: ScheduleDownload :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def schedule_download_for_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
schedule_download: ScheduleDownload) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def schedule_download_for_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    schedule_download: ScheduleDownload,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Schedule a download.

    Endpoint for scheduling a download for the data specified by the ID to a connector. This download will only start when the connector is running. Data transfers for folder contents are created asynchronously, meaning that they will not be immediately visible in the project data transfers end point. Note: The localPath field is optional. When omitted or invalid, the download rules of the connector are followed.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param schedule_download: (required)
    :type schedule_download: ScheduleDownload
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._schedule_download_for_data_serialize(
        project_id=project_id,
        data_id=data_id,
        schedule_download=schedule_download,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Schedule a download.

Endpoint for scheduling a download for the data specified by the ID to a connector. This download will only start when the connector is running. Data transfers for folder contents are created asynchronously, meaning that they will not be immediately visible in the project data transfers end point. Note: The localPath field is optional. When omitted or invalid, the download rules of the connector are followed.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param schedule_download: (required) :type schedule_download: ScheduleDownload :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unarchive_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def unarchive_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Schedule this data for unarchival.

    Endpoint for scheduling this data for unarchival. This will also unarchive all files and directories below that data. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unarchive_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Schedule this data for unarchival.

Endpoint for scheduling this data for unarchival. This will also unarchive all files and directories below that data. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unarchive_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unarchive_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Schedule this data for unarchival.

    Endpoint for scheduling this data for unarchival. This will also unarchive all files and directories below that data. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unarchive_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Schedule this data for unarchival.

Endpoint for scheduling this data for unarchival. This will also unarchive all files and directories below that data. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unarchive_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unarchive_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Schedule this data for unarchival.

    Endpoint for scheduling this data for unarchival. This will also unarchive all files and directories below that data. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unarchive_data_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Schedule this data for unarchival.

Endpoint for scheduling this data for unarchival. This will also unarchive all files and directories below that data. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_data_from_project(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def unlink_data_from_project(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Unlink data from this project.

    Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Project Data Unlinking Batch' for recursive unlinking.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_data_from_project_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Unlink data from this project.

Note that for folders, this only unlinks the folder itself, not the folder contents! Use 'Project Data Unlinking Batch' for recursive unlinking.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_data_from_project_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unlink_data_from_project_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Unlink data from this project.

    Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Project Data Unlinking Batch' for recursive unlinking.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_data_from_project_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Unlink data from this project.

Note that for folders, this only unlinks the folder itself, not the folder contents! Use 'Project Data Unlinking Batch' for recursive unlinking.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_data_from_project_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unlink_data_from_project_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Unlink data from this project.

    Note that for folders, this only unlinks the folder itself, not the folder contents!  Use 'Project Data Unlinking Batch' for recursive unlinking.

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_data_from_project_serialize(
        project_id=project_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Unlink data from this project.

Note that for folders, this only unlinks the folder itself, not the folder contents! Use 'Project Data Unlinking Batch' for recursive unlinking.

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_data(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
project_data: Annotated[ProjectData, FieldInfo(annotation=NoneType, required=True, description='The updated project data.')]) ‑> ProjectData

Expand source code

@validate_call
def update_project_data(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    project_data: Annotated[ProjectData, Field(description="The updated project data.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectData:
    """Update this project data.

    Fields which can be updated for files:  - data.willBeArchivedAt  - data.willBeDeletedAt  - data.format  - data.tags  Fields which can be updated for folders:  - data.tags  

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param project_data: The updated project data. (required)
    :type project_data: ProjectData
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_data_serialize(
        project_id=project_id,
        data_id=data_id,
        project_data=project_data,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update this project data.

Fields which can be updated for files: - data.willBeArchivedAt - data.willBeDeletedAt - data.format - data.tags Fields which can be updated for folders: - data.tags

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param project_data: The updated project data. (required) :type project_data: ProjectData :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_data_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
project_data: Annotated[ProjectData, FieldInfo(annotation=NoneType, required=True, description='The updated project data.')]) ‑> ApiResponse[ProjectData]

Expand source code

@validate_call
def update_project_data_with_http_info(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    project_data: Annotated[ProjectData, Field(description="The updated project data.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectData]:
    """Update this project data.

    Fields which can be updated for files:  - data.willBeArchivedAt  - data.willBeDeletedAt  - data.format  - data.tags  Fields which can be updated for folders:  - data.tags  

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param project_data: The updated project data. (required)
    :type project_data: ProjectData
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_data_serialize(
        project_id=project_id,
        data_id=data_id,
        project_data=project_data,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update this project data.

Fields which can be updated for files: - data.willBeArchivedAt - data.willBeDeletedAt - data.format - data.tags Fields which can be updated for folders: - data.tags

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param project_data: The updated project data. (required) :type project_data: ProjectData :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_data_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_id: Annotated[str, Strict(strict=True)],
project_data: Annotated[ProjectData, FieldInfo(annotation=NoneType, required=True, description='The updated project data.')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_project_data_without_preload_content(
    self,
    project_id: StrictStr,
    data_id: StrictStr,
    project_data: Annotated[ProjectData, Field(description="The updated project data.")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update this project data.

    Fields which can be updated for files:  - data.willBeArchivedAt  - data.willBeDeletedAt  - data.format  - data.tags  Fields which can be updated for folders:  - data.tags  

    :param project_id: (required)
    :type project_id: str
    :param data_id: (required)
    :type data_id: str
    :param project_data: The updated project data. (required)
    :type project_data: ProjectData
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_data_serialize(
        project_id=project_id,
        data_id=data_id,
        project_data=project_data,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectData",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update this project data.

Fields which can be updated for files: - data.willBeArchivedAt - data.willBeDeletedAt - data.format - data.tags Fields which can be updated for folders: - data.tags

:param project_id: (required) :type project_id: str :param data_id: (required) :type data_id: str :param project_data: The updated project data. (required) :type project_data: ProjectData :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectDataCopyBatch (**data: Any)

Expand source code

class ProjectDataCopyBatch(BaseModel):
    """
    ProjectDataCopyBatch
    """ # noqa: E501
    id: StrictStr
    job: Optional[Job]
    destination_folder_id: Optional[StrictStr] = Field(default=None, alias="destinationFolderId")
    copy_user_tags: StrictBool = Field(alias="copyUserTags")
    copy_technical_tags: StrictBool = Field(alias="copyTechnicalTags")
    copy_instrument_info: StrictBool = Field(alias="copyInstrumentInfo")
    action_on_exist: StrictStr = Field(alias="actionOnExist")
    __properties: ClassVar[List[str]] = ["id", "job", "destinationFolderId", "copyUserTags", "copyTechnicalTags", "copyInstrumentInfo", "actionOnExist"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of job
        if self.job:
            _dict['job'] = self.job.to_dict()
        # set to None if job (nullable) is None
        # and model_fields_set contains the field
        if self.job is None and "job" in self.model_fields_set:
            _dict['job'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "job": Job.from_dict(obj["job"]) if obj.get("job") is not None else None,
            "destinationFolderId": obj.get("destinationFolderId"),
            "copyUserTags": obj.get("copyUserTags"),
            "copyTechnicalTags": obj.get("copyTechnicalTags"),
            "copyInstrumentInfo": obj.get("copyInstrumentInfo"),
            "actionOnExist": obj.get("actionOnExist")
        })
        return _obj

ProjectDataCopyBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var action_on_exist : str

The type of the None singleton.

var copy_instrument_info : bool

The type of the None singleton.

var copy_technical_tags : bool

The type of the None singleton.

var copy_user_tags : bool

The type of the None singleton.

var destination_folder_id : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var job : Job | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataCopyBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataCopyBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of job
    if self.job:
        _dict['job'] = self.job.to_dict()
    # set to None if job (nullable) is None
    # and model_fields_set contains the field
    if self.job is None and "job" in self.model_fields_set:
        _dict['job'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataCopyBatchApi (api_client=None)

Expand source code

class ProjectDataCopyBatchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_project_data_copy_batch(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be copied")],
        create_project_data_copy_batch: CreateProjectDataCopyBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataCopyBatch:
        """Create a project data copy batch.


        :param project_id: The ID of the project to which the data will be copied (required)
        :type project_id: str
        :param create_project_data_copy_batch: (required)
        :type create_project_data_copy_batch: CreateProjectDataCopyBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_copy_batch_serialize(
            project_id=project_id,
            create_project_data_copy_batch=create_project_data_copy_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataCopyBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_project_data_copy_batch_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be copied")],
        create_project_data_copy_batch: CreateProjectDataCopyBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataCopyBatch]:
        """Create a project data copy batch.


        :param project_id: The ID of the project to which the data will be copied (required)
        :type project_id: str
        :param create_project_data_copy_batch: (required)
        :type create_project_data_copy_batch: CreateProjectDataCopyBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_copy_batch_serialize(
            project_id=project_id,
            create_project_data_copy_batch=create_project_data_copy_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataCopyBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_project_data_copy_batch_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be copied")],
        create_project_data_copy_batch: CreateProjectDataCopyBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a project data copy batch.


        :param project_id: The ID of the project to which the data will be copied (required)
        :type project_id: str
        :param create_project_data_copy_batch: (required)
        :type create_project_data_copy_batch: CreateProjectDataCopyBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_copy_batch_serialize(
            project_id=project_id,
            create_project_data_copy_batch=create_project_data_copy_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataCopyBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_project_data_copy_batch_serialize(
        self,
        project_id,
        create_project_data_copy_batch,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_project_data_copy_batch is not None:
            _body_params = create_project_data_copy_batch


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/dataCopyBatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_copy_batch(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataCopyBatch:
        """Retrieve a project data copy batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_copy_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataCopyBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_copy_batch_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataCopyBatch]:
        """Retrieve a project data copy batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_copy_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataCopyBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_copy_batch_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data copy batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_copy_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataCopyBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_copy_batch_serialize(
        self,
        project_id,
        batch_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataCopyBatch/{batchId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_copy_batch_item(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataCopyBatchItem:
        """Retrieve a project data copy batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_copy_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataCopyBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_copy_batch_item_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataCopyBatchItem]:
        """Retrieve a project data copy batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_copy_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataCopyBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_copy_batch_item_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data copy batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_copy_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataCopyBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_copy_batch_item_serialize(
        self,
        project_id,
        batch_id,
        item_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        if item_id is not None:
            _path_params['itemId'] = item_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataCopyBatch/{batchId}/items/{itemId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_copy_batch_items(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataCopyBatchItemPagedList:
        """Retrieve a list of project data copy batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_copy_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataCopyBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_copy_batch_items_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataCopyBatchItemPagedList]:
        """Retrieve a list of project data copy batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_copy_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataCopyBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_copy_batch_items_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of project data copy batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_copy_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataCopyBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_copy_batch_items_serialize(
        self,
        project_id,
        batch_id,
        status,
        page_offset,
        page_token,
        page_size,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataCopyBatch/{batchId}/items',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_project_data_copy_batch(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to which the data will be copied')],
create_project_data_copy_batch: CreateProjectDataCopyBatch) ‑> ProjectDataCopyBatch

Expand source code

@validate_call
def create_project_data_copy_batch(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be copied")],
    create_project_data_copy_batch: CreateProjectDataCopyBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataCopyBatch:
    """Create a project data copy batch.


    :param project_id: The ID of the project to which the data will be copied (required)
    :type project_id: str
    :param create_project_data_copy_batch: (required)
    :type create_project_data_copy_batch: CreateProjectDataCopyBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_copy_batch_serialize(
        project_id=project_id,
        create_project_data_copy_batch=create_project_data_copy_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataCopyBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a project data copy batch.

:param project_id: The ID of the project to which the data will be copied (required) :type project_id: str :param create_project_data_copy_batch: (required) :type create_project_data_copy_batch: CreateProjectDataCopyBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_copy_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to which the data will be copied')],
create_project_data_copy_batch: CreateProjectDataCopyBatch) ‑> ApiResponse[ProjectDataCopyBatch]

Expand source code

@validate_call
def create_project_data_copy_batch_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be copied")],
    create_project_data_copy_batch: CreateProjectDataCopyBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataCopyBatch]:
    """Create a project data copy batch.


    :param project_id: The ID of the project to which the data will be copied (required)
    :type project_id: str
    :param create_project_data_copy_batch: (required)
    :type create_project_data_copy_batch: CreateProjectDataCopyBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_copy_batch_serialize(
        project_id=project_id,
        create_project_data_copy_batch=create_project_data_copy_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataCopyBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a project data copy batch.

:param project_id: The ID of the project to which the data will be copied (required) :type project_id: str :param create_project_data_copy_batch: (required) :type create_project_data_copy_batch: CreateProjectDataCopyBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_copy_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to which the data will be copied')],
create_project_data_copy_batch: CreateProjectDataCopyBatch) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_project_data_copy_batch_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be copied")],
    create_project_data_copy_batch: CreateProjectDataCopyBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a project data copy batch.


    :param project_id: The ID of the project to which the data will be copied (required)
    :type project_id: str
    :param create_project_data_copy_batch: (required)
    :type create_project_data_copy_batch: CreateProjectDataCopyBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_copy_batch_serialize(
        project_id=project_id,
        create_project_data_copy_batch=create_project_data_copy_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataCopyBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a project data copy batch.

:param project_id: The ID of the project to which the data will be copied (required) :type project_id: str :param create_project_data_copy_batch: (required) :type create_project_data_copy_batch: CreateProjectDataCopyBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_copy_batch(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataCopyBatch

Expand source code

@validate_call
def get_project_data_copy_batch(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataCopyBatch:
    """Retrieve a project data copy batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_copy_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataCopyBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data copy batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_copy_batch_item(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataCopyBatchItem

Expand source code

@validate_call
def get_project_data_copy_batch_item(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataCopyBatchItem:
    """Retrieve a project data copy batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_copy_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataCopyBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data copy batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_copy_batch_item_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataCopyBatchItem]

Expand source code

@validate_call
def get_project_data_copy_batch_item_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataCopyBatchItem]:
    """Retrieve a project data copy batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_copy_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataCopyBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data copy batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_copy_batch_item_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_copy_batch_item_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data copy batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_copy_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataCopyBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data copy batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_copy_batch_items(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ProjectDataCopyBatchItemPagedList

Expand source code

@validate_call
def get_project_data_copy_batch_items(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataCopyBatchItemPagedList:
    """Retrieve a list of project data copy batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_copy_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataCopyBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of project data copy batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_copy_batch_items_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ApiResponse[ProjectDataCopyBatchItemPagedList]

Expand source code

@validate_call
def get_project_data_copy_batch_items_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataCopyBatchItemPagedList]:
    """Retrieve a list of project data copy batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_copy_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataCopyBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of project data copy batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_copy_batch_items_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_copy_batch_items_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of project data copy batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_copy_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataCopyBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of project data copy batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_copy_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataCopyBatch]

Expand source code

@validate_call
def get_project_data_copy_batch_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataCopyBatch]:
    """Retrieve a project data copy batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_copy_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataCopyBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data copy batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_copy_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_copy_batch_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data copy batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_copy_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataCopyBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data copy batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectDataCopyBatchItem (**data: Any)

Expand source code

class ProjectDataCopyBatchItem(BaseModel):
    """
    ProjectDataCopyBatchItem
    """ # noqa: E501
    id: StrictStr
    request: ProjectDataCopyBatchItemRequest
    processing: ProjectDataCopyBatchItemProcessing
    created_project_data: Optional[ProjectData] = Field(default=None, alias="createdProjectData")
    __properties: ClassVar[List[str]] = ["id", "request", "processing", "createdProjectData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        # override the default output from pydantic by calling `to_dict()` of created_project_data
        if self.created_project_data:
            _dict['createdProjectData'] = self.created_project_data.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": ProjectDataCopyBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": ProjectDataCopyBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None,
            "createdProjectData": ProjectData.from_dict(obj["createdProjectData"]) if obj.get("createdProjectData") is not None else None
        })
        return _obj

ProjectDataCopyBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var created_project_data : ProjectData | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : ProjectDataCopyBatchItemProcessing

The type of the None singleton.

var request : ProjectDataCopyBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataCopyBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataCopyBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    # override the default output from pydantic by calling `to_dict()` of created_project_data
    if self.created_project_data:
        _dict['createdProjectData'] = self.created_project_data.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataCopyBatchItemPagedList (**data: Any)

Expand source code

class ProjectDataCopyBatchItemPagedList(BaseModel):
    """
    ProjectDataCopyBatchItemPagedList
    """ # noqa: E501
    items: List[ProjectDataCopyBatchItem]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatchItemPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatchItemPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectDataCopyBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

ProjectDataCopyBatchItemPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectDataCopyBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataCopyBatchItemPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataCopyBatchItemPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataCopyBatchItemProcessing (**data: Any)

Expand source code

class ProjectDataCopyBatchItemProcessing(BaseModel):
    """
    ProjectDataCopyBatchItemProcessing
    """ # noqa: E501
    status: StrictStr
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['QUEUED', 'COPYING', 'COPIED', 'PARTIALLY_COPIED', 'FAILED']):
            raise ValueError("must be one of enum values ('QUEUED', 'COPYING', 'COPIED', 'PARTIALLY_COPIED', 'FAILED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatchItemProcessing from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatchItemProcessing from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

ProjectDataCopyBatchItemProcessing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataCopyBatchItemProcessing from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataCopyBatchItemProcessing from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataCopyBatchItemRequest (**data: Any)

Expand source code

class ProjectDataCopyBatchItemRequest(BaseModel):
    """
    ProjectDataCopyBatchItemRequest
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatchItemRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataCopyBatchItemRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

ProjectDataCopyBatchItemRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataCopyBatchItemRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataCopyBatchItemRequest from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataLinkingBatch (**data: Any)

Expand source code

class ProjectDataLinkingBatch(BaseModel):
    """
    ProjectDataLinkingBatch
    """ # noqa: E501
    id: StrictStr
    job: Optional[Job]
    __properties: ClassVar[List[str]] = ["id", "job"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of job
        if self.job:
            _dict['job'] = self.job.to_dict()
        # set to None if job (nullable) is None
        # and model_fields_set contains the field
        if self.job is None and "job" in self.model_fields_set:
            _dict['job'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "job": Job.from_dict(obj["job"]) if obj.get("job") is not None else None
        })
        return _obj

ProjectDataLinkingBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var job : Job | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataLinkingBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataLinkingBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of job
    if self.job:
        _dict['job'] = self.job.to_dict()
    # set to None if job (nullable) is None
    # and model_fields_set contains the field
    if self.job is None and "job" in self.model_fields_set:
        _dict['job'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataLinkingBatchApi (api_client=None)

Expand source code

class ProjectDataLinkingBatchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_project_data_linking_batch(
        self,
        project_id: StrictStr,
        create_project_data_linking_batch: CreateProjectDataLinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataLinkingBatch:
        """Create a project data linking batch.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version deprecated.  It's recommended to limit the amount of links per batch to 25.000. Recommended to use V4 for performance efficiency. ## [V4] More efficient, handles folder contents via the folder item, instead of creating separate items for all contents. 

        :param project_id: (required)
        :type project_id: str
        :param create_project_data_linking_batch: (required)
        :type create_project_data_linking_batch: CreateProjectDataLinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_linking_batch_serialize(
            project_id=project_id,
            create_project_data_linking_batch=create_project_data_linking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_project_data_linking_batch_with_http_info(
        self,
        project_id: StrictStr,
        create_project_data_linking_batch: CreateProjectDataLinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataLinkingBatch]:
        """Create a project data linking batch.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version deprecated.  It's recommended to limit the amount of links per batch to 25.000. Recommended to use V4 for performance efficiency. ## [V4] More efficient, handles folder contents via the folder item, instead of creating separate items for all contents. 

        :param project_id: (required)
        :type project_id: str
        :param create_project_data_linking_batch: (required)
        :type create_project_data_linking_batch: CreateProjectDataLinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_linking_batch_serialize(
            project_id=project_id,
            create_project_data_linking_batch=create_project_data_linking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_project_data_linking_batch_without_preload_content(
        self,
        project_id: StrictStr,
        create_project_data_linking_batch: CreateProjectDataLinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a project data linking batch.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version deprecated.  It's recommended to limit the amount of links per batch to 25.000. Recommended to use V4 for performance efficiency. ## [V4] More efficient, handles folder contents via the folder item, instead of creating separate items for all contents. 

        :param project_id: (required)
        :type project_id: str
        :param create_project_data_linking_batch: (required)
        :type create_project_data_linking_batch: CreateProjectDataLinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_linking_batch_serialize(
            project_id=project_id,
            create_project_data_linking_batch=create_project_data_linking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_project_data_linking_batch_serialize(
        self,
        project_id,
        create_project_data_linking_batch,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_project_data_linking_batch is not None:
            _body_params = create_project_data_linking_batch


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json', 
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/dataLinkingBatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_linking_batch(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataLinkingBatch:
        """Retrieve a project data linking batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_linking_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_linking_batch_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataLinkingBatch]:
        """Retrieve a project data linking batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_linking_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_linking_batch_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data linking batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_linking_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataLinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_linking_batch_serialize(
        self,
        project_id,
        batch_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataLinkingBatch/{batchId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_linking_batch_item(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataLinkingBatchItemV4:
        """Retrieve a project data linking batch item.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_linking_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataLinkingBatchItemV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_linking_batch_item_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataLinkingBatchItemV4]:
        """Retrieve a project data linking batch item.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_linking_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataLinkingBatchItemV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_linking_batch_item_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data linking batch item.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_linking_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataLinkingBatchItemV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_linking_batch_item_serialize(
        self,
        project_id,
        batch_id,
        item_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        if item_id is not None:
            _path_params['itemId'] = item_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataLinkingBatch/{batchId}/items/{itemId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_linking_batch_items(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataLinkingBatchItemPagedListV4:
        """Retrieve a list of project data linking batch items.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_linking_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataLinkingBatchItemPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_linking_batch_items_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataLinkingBatchItemPagedListV4]:
        """Retrieve a list of project data linking batch items.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_linking_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataLinkingBatchItemPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_linking_batch_items_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of project data linking batch items.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_linking_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataLinkingBatchItemPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_linking_batch_items_serialize(
        self,
        project_id,
        batch_id,
        status,
        page_offset,
        page_token,
        page_size,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataLinkingBatch/{batchId}/items',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_project_data_linking_batch(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_data_linking_batch: CreateProjectDataLinkingBatch) ‑> ProjectDataLinkingBatch

Expand source code

@validate_call
def create_project_data_linking_batch(
    self,
    project_id: StrictStr,
    create_project_data_linking_batch: CreateProjectDataLinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataLinkingBatch:
    """Create a project data linking batch.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version deprecated.  It's recommended to limit the amount of links per batch to 25.000. Recommended to use V4 for performance efficiency. ## [V4] More efficient, handles folder contents via the folder item, instead of creating separate items for all contents. 

    :param project_id: (required)
    :type project_id: str
    :param create_project_data_linking_batch: (required)
    :type create_project_data_linking_batch: CreateProjectDataLinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_linking_batch_serialize(
        project_id=project_id,
        create_project_data_linking_batch=create_project_data_linking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a project data linking batch.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version deprecated. It's recommended to limit the amount of links per batch to 25.000. Recommended to use V4 for performance efficiency. ## [V4] More efficient, handles folder contents via the folder item, instead of creating separate items for all contents.

:param project_id: (required) :type project_id: str :param create_project_data_linking_batch: (required) :type create_project_data_linking_batch: CreateProjectDataLinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_linking_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_data_linking_batch: CreateProjectDataLinkingBatch) ‑> ApiResponse[ProjectDataLinkingBatch]

Expand source code

@validate_call
def create_project_data_linking_batch_with_http_info(
    self,
    project_id: StrictStr,
    create_project_data_linking_batch: CreateProjectDataLinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataLinkingBatch]:
    """Create a project data linking batch.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version deprecated.  It's recommended to limit the amount of links per batch to 25.000. Recommended to use V4 for performance efficiency. ## [V4] More efficient, handles folder contents via the folder item, instead of creating separate items for all contents. 

    :param project_id: (required)
    :type project_id: str
    :param create_project_data_linking_batch: (required)
    :type create_project_data_linking_batch: CreateProjectDataLinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_linking_batch_serialize(
        project_id=project_id,
        create_project_data_linking_batch=create_project_data_linking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a project data linking batch.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version deprecated. It's recommended to limit the amount of links per batch to 25.000. Recommended to use V4 for performance efficiency. ## [V4] More efficient, handles folder contents via the folder item, instead of creating separate items for all contents.

:param project_id: (required) :type project_id: str :param create_project_data_linking_batch: (required) :type create_project_data_linking_batch: CreateProjectDataLinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_linking_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_data_linking_batch: CreateProjectDataLinkingBatch) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_project_data_linking_batch_without_preload_content(
    self,
    project_id: StrictStr,
    create_project_data_linking_batch: CreateProjectDataLinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a project data linking batch.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version deprecated.  It's recommended to limit the amount of links per batch to 25.000. Recommended to use V4 for performance efficiency. ## [V4] More efficient, handles folder contents via the folder item, instead of creating separate items for all contents. 

    :param project_id: (required)
    :type project_id: str
    :param create_project_data_linking_batch: (required)
    :type create_project_data_linking_batch: CreateProjectDataLinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_linking_batch_serialize(
        project_id=project_id,
        create_project_data_linking_batch=create_project_data_linking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a project data linking batch.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version deprecated. It's recommended to limit the amount of links per batch to 25.000. Recommended to use V4 for performance efficiency. ## [V4] More efficient, handles folder contents via the folder item, instead of creating separate items for all contents.

:param project_id: (required) :type project_id: str :param create_project_data_linking_batch: (required) :type create_project_data_linking_batch: CreateProjectDataLinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_linking_batch(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataLinkingBatch

Expand source code

@validate_call
def get_project_data_linking_batch(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataLinkingBatch:
    """Retrieve a project data linking batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_linking_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data linking batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_linking_batch_item(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataLinkingBatchItemV4

Expand source code

@validate_call
def get_project_data_linking_batch_item(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataLinkingBatchItemV4:
    """Retrieve a project data linking batch item.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_linking_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataLinkingBatchItemV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data linking batch item.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_linking_batch_item_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataLinkingBatchItemV4]

Expand source code

@validate_call
def get_project_data_linking_batch_item_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataLinkingBatchItemV4]:
    """Retrieve a project data linking batch item.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_linking_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataLinkingBatchItemV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data linking batch item.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_linking_batch_item_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_linking_batch_item_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data linking batch item.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_linking_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataLinkingBatchItemV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data linking batch item.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_linking_batch_items(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ProjectDataLinkingBatchItemPagedListV4

Expand source code

@validate_call
def get_project_data_linking_batch_items(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataLinkingBatchItemPagedListV4:
    """Retrieve a list of project data linking batch items.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_linking_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataLinkingBatchItemPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of project data linking batch items.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_linking_batch_items_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ApiResponse[ProjectDataLinkingBatchItemPagedListV4]

Expand source code

@validate_call
def get_project_data_linking_batch_items_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataLinkingBatchItemPagedListV4]:
    """Retrieve a list of project data linking batch items.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_linking_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataLinkingBatchItemPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of project data linking batch items.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_linking_batch_items_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_linking_batch_items_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of project data linking batch items.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status. 

    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_linking_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataLinkingBatchItemPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of project data linking batch items.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version, deprecated, returns PARTIALLY_LINKED item processing status as FAILED. ## [V4] Supports PARTIALLY_LINKED item processing status.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_linking_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataLinkingBatch]

Expand source code

@validate_call
def get_project_data_linking_batch_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataLinkingBatch]:
    """Retrieve a project data linking batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_linking_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data linking batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_linking_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_linking_batch_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data linking batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_linking_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataLinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data linking batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectDataLinkingBatchItem (**data: Any)

Expand source code

class ProjectDataLinkingBatchItem(BaseModel):
    """
    ProjectDataLinkingBatchItem
    """ # noqa: E501
    id: StrictStr
    request: ProjectDataLinkingBatchItemRequest
    processing: ProjectDataLinkingBatchItemProcessing
    created_project_data: Optional[ProjectData] = Field(default=None, alias="createdProjectData")
    __properties: ClassVar[List[str]] = ["id", "request", "processing", "createdProjectData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        # override the default output from pydantic by calling `to_dict()` of created_project_data
        if self.created_project_data:
            _dict['createdProjectData'] = self.created_project_data.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": ProjectDataLinkingBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": ProjectDataLinkingBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None,
            "createdProjectData": ProjectData.from_dict(obj["createdProjectData"]) if obj.get("createdProjectData") is not None else None
        })
        return _obj

ProjectDataLinkingBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var created_project_data : ProjectData | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : ProjectDataLinkingBatchItemProcessing

The type of the None singleton.

var request : ProjectDataLinkingBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    # override the default output from pydantic by calling `to_dict()` of created_project_data
    if self.created_project_data:
        _dict['createdProjectData'] = self.created_project_data.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataLinkingBatchItemPagedList (**data: Any)

Expand source code

class ProjectDataLinkingBatchItemPagedList(BaseModel):
    """
    ProjectDataLinkingBatchItemPagedList
    """ # noqa: E501
    items: List[ProjectDataLinkingBatchItem]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectDataLinkingBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

ProjectDataLinkingBatchItemPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectDataLinkingBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataLinkingBatchItemPagedListV4 (**data: Any)

Expand source code

class ProjectDataLinkingBatchItemPagedListV4(BaseModel):
    """
    ProjectDataLinkingBatchItemPagedListV4
    """ # noqa: E501
    items: List[ProjectDataLinkingBatchItemV4]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemPagedListV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemPagedListV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectDataLinkingBatchItemV4.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

ProjectDataLinkingBatchItemPagedListV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectDataLinkingBatchItemV4]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemPagedListV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemPagedListV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataLinkingBatchItemProcessing (**data: Any)

Expand source code

class ProjectDataLinkingBatchItemProcessing(BaseModel):
    """
    ProjectDataLinkingBatchItemProcessing
    """ # noqa: E501
    status: StrictStr
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['INITIALISED', 'WAITING_RESOURCES', 'RUNNING', 'LINKED', 'ALREADY_LINKED', 'FAILED']):
            raise ValueError("must be one of enum values ('INITIALISED', 'WAITING_RESOURCES', 'RUNNING', 'LINKED', 'ALREADY_LINKED', 'FAILED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemProcessing from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemProcessing from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

ProjectDataLinkingBatchItemProcessing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemProcessing from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemProcessing from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataLinkingBatchItemProcessingV4 (**data: Any)

Expand source code

class ProjectDataLinkingBatchItemProcessingV4(BaseModel):
    """
    ProjectDataLinkingBatchItemProcessingV4
    """ # noqa: E501
    status: StrictStr = Field(description="Possible values are: INITIALISED, WAITING_RESOURCES, RUNNING, LINKED, ALREADY_LINKED, FAILED, PARTIALLY_LINKED. More types could be added in a future release.")
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemProcessingV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemProcessingV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

ProjectDataLinkingBatchItemProcessingV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemProcessingV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemProcessingV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataLinkingBatchItemRequest (**data: Any)

Expand source code

class ProjectDataLinkingBatchItemRequest(BaseModel):
    """
    ProjectDataLinkingBatchItemRequest
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

ProjectDataLinkingBatchItemRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemRequest from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataLinkingBatchItemV4 (**data: Any)

Expand source code

class ProjectDataLinkingBatchItemV4(BaseModel):
    """
    ProjectDataLinkingBatchItemV4
    """ # noqa: E501
    id: StrictStr
    request: ProjectDataLinkingBatchItemRequest
    processing: ProjectDataLinkingBatchItemProcessingV4
    created_project_data: Optional[ProjectData] = Field(default=None, alias="createdProjectData")
    __properties: ClassVar[List[str]] = ["id", "request", "processing", "createdProjectData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        # override the default output from pydantic by calling `to_dict()` of created_project_data
        if self.created_project_data:
            _dict['createdProjectData'] = self.created_project_data.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataLinkingBatchItemV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": ProjectDataLinkingBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": ProjectDataLinkingBatchItemProcessingV4.from_dict(obj["processing"]) if obj.get("processing") is not None else None,
            "createdProjectData": ProjectData.from_dict(obj["createdProjectData"]) if obj.get("createdProjectData") is not None else None
        })
        return _obj

ProjectDataLinkingBatchItemV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var created_project_data : ProjectData | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : ProjectDataLinkingBatchItemProcessingV4

The type of the None singleton.

var request : ProjectDataLinkingBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataLinkingBatchItemV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    # override the default output from pydantic by calling `to_dict()` of created_project_data
    if self.created_project_data:
        _dict['createdProjectData'] = self.created_project_data.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataMoveBatch (**data: Any)

Expand source code

class ProjectDataMoveBatch(BaseModel):
    """
    ProjectDataMoveBatch
    """ # noqa: E501
    id: StrictStr
    job: Optional[Job]
    destination_folder_id: Optional[StrictStr] = Field(default=None, alias="destinationFolderId")
    __properties: ClassVar[List[str]] = ["id", "job", "destinationFolderId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of job
        if self.job:
            _dict['job'] = self.job.to_dict()
        # set to None if job (nullable) is None
        # and model_fields_set contains the field
        if self.job is None and "job" in self.model_fields_set:
            _dict['job'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "job": Job.from_dict(obj["job"]) if obj.get("job") is not None else None,
            "destinationFolderId": obj.get("destinationFolderId")
        })
        return _obj

ProjectDataMoveBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var destination_folder_id : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var job : Job | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataMoveBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataMoveBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of job
    if self.job:
        _dict['job'] = self.job.to_dict()
    # set to None if job (nullable) is None
    # and model_fields_set contains the field
    if self.job is None and "job" in self.model_fields_set:
        _dict['job'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataMoveBatchApi (api_client=None)

Expand source code

class ProjectDataMoveBatchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_project_data_move_batch(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be moved")],
        create_project_data_move_batch: CreateProjectDataMoveBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataMoveBatch:
        """Create a project data move batch.


        :param project_id: The ID of the project to which the data will be moved (required)
        :type project_id: str
        :param create_project_data_move_batch: (required)
        :type create_project_data_move_batch: CreateProjectDataMoveBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_move_batch_serialize(
            project_id=project_id,
            create_project_data_move_batch=create_project_data_move_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataMoveBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_project_data_move_batch_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be moved")],
        create_project_data_move_batch: CreateProjectDataMoveBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataMoveBatch]:
        """Create a project data move batch.


        :param project_id: The ID of the project to which the data will be moved (required)
        :type project_id: str
        :param create_project_data_move_batch: (required)
        :type create_project_data_move_batch: CreateProjectDataMoveBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_move_batch_serialize(
            project_id=project_id,
            create_project_data_move_batch=create_project_data_move_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataMoveBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_project_data_move_batch_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be moved")],
        create_project_data_move_batch: CreateProjectDataMoveBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a project data move batch.


        :param project_id: The ID of the project to which the data will be moved (required)
        :type project_id: str
        :param create_project_data_move_batch: (required)
        :type create_project_data_move_batch: CreateProjectDataMoveBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_move_batch_serialize(
            project_id=project_id,
            create_project_data_move_batch=create_project_data_move_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataMoveBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_project_data_move_batch_serialize(
        self,
        project_id,
        create_project_data_move_batch,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_project_data_move_batch is not None:
            _body_params = create_project_data_move_batch


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/dataMoveBatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_move_batch(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataMoveBatch:
        """Retrieve a project data move batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_move_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataMoveBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_move_batch_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataMoveBatch]:
        """Retrieve a project data move batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_move_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataMoveBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_move_batch_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data move batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_move_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataMoveBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_move_batch_serialize(
        self,
        project_id,
        batch_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataMoveBatch/{batchId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_move_batch_item(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataMoveBatchItem:
        """Retrieve a project data move batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_move_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataMoveBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_move_batch_item_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataMoveBatchItem]:
        """Retrieve a project data move batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_move_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataMoveBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_move_batch_item_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data move batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_move_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataMoveBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_move_batch_item_serialize(
        self,
        project_id,
        batch_id,
        item_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        if item_id is not None:
            _path_params['itemId'] = item_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataMoveBatch/{batchId}/items/{itemId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_move_batch_items(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        project_data_move_batch_item_query_parameters: Optional[ProjectDataMoveBatchItemQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataMoveBatchItemPagedList:
        """Retrieve a list of project data move batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param project_data_move_batch_item_query_parameters:
        :type project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_move_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            project_data_move_batch_item_query_parameters=project_data_move_batch_item_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataMoveBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_move_batch_items_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        project_data_move_batch_item_query_parameters: Optional[ProjectDataMoveBatchItemQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataMoveBatchItemPagedList]:
        """Retrieve a list of project data move batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param project_data_move_batch_item_query_parameters:
        :type project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_move_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            project_data_move_batch_item_query_parameters=project_data_move_batch_item_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataMoveBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_move_batch_items_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        project_data_move_batch_item_query_parameters: Optional[ProjectDataMoveBatchItemQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of project data move batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param project_data_move_batch_item_query_parameters:
        :type project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_move_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            project_data_move_batch_item_query_parameters=project_data_move_batch_item_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataMoveBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_move_batch_items_serialize(
        self,
        project_id,
        batch_id,
        page_offset,
        page_token,
        page_size,
        project_data_move_batch_item_query_parameters,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if project_data_move_batch_item_query_parameters is not None:
            _body_params = project_data_move_batch_item_query_parameters


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/dataMoveBatch/{batchId}/items:search',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_project_data_move_batch(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to which the data will be moved')],
create_project_data_move_batch: CreateProjectDataMoveBatch) ‑> ProjectDataMoveBatch

Expand source code

@validate_call
def create_project_data_move_batch(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be moved")],
    create_project_data_move_batch: CreateProjectDataMoveBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataMoveBatch:
    """Create a project data move batch.


    :param project_id: The ID of the project to which the data will be moved (required)
    :type project_id: str
    :param create_project_data_move_batch: (required)
    :type create_project_data_move_batch: CreateProjectDataMoveBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_move_batch_serialize(
        project_id=project_id,
        create_project_data_move_batch=create_project_data_move_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataMoveBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a project data move batch.

:param project_id: The ID of the project to which the data will be moved (required) :type project_id: str :param create_project_data_move_batch: (required) :type create_project_data_move_batch: CreateProjectDataMoveBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_move_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to which the data will be moved')],
create_project_data_move_batch: CreateProjectDataMoveBatch) ‑> ApiResponse[ProjectDataMoveBatch]

Expand source code

@validate_call
def create_project_data_move_batch_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be moved")],
    create_project_data_move_batch: CreateProjectDataMoveBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataMoveBatch]:
    """Create a project data move batch.


    :param project_id: The ID of the project to which the data will be moved (required)
    :type project_id: str
    :param create_project_data_move_batch: (required)
    :type create_project_data_move_batch: CreateProjectDataMoveBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_move_batch_serialize(
        project_id=project_id,
        create_project_data_move_batch=create_project_data_move_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataMoveBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a project data move batch.

:param project_id: The ID of the project to which the data will be moved (required) :type project_id: str :param create_project_data_move_batch: (required) :type create_project_data_move_batch: CreateProjectDataMoveBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_move_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to which the data will be moved')],
create_project_data_move_batch: CreateProjectDataMoveBatch) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_project_data_move_batch_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project to which the data will be moved")],
    create_project_data_move_batch: CreateProjectDataMoveBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a project data move batch.


    :param project_id: The ID of the project to which the data will be moved (required)
    :type project_id: str
    :param create_project_data_move_batch: (required)
    :type create_project_data_move_batch: CreateProjectDataMoveBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_move_batch_serialize(
        project_id=project_id,
        create_project_data_move_batch=create_project_data_move_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataMoveBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a project data move batch.

:param project_id: The ID of the project to which the data will be moved (required) :type project_id: str :param create_project_data_move_batch: (required) :type create_project_data_move_batch: CreateProjectDataMoveBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_move_batch(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataMoveBatch

Expand source code

@validate_call
def get_project_data_move_batch(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataMoveBatch:
    """Retrieve a project data move batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_move_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataMoveBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data move batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_move_batch_item(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataMoveBatchItem

Expand source code

@validate_call
def get_project_data_move_batch_item(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataMoveBatchItem:
    """Retrieve a project data move batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_move_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataMoveBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data move batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_move_batch_item_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataMoveBatchItem]

Expand source code

@validate_call
def get_project_data_move_batch_item_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataMoveBatchItem]:
    """Retrieve a project data move batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_move_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataMoveBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data move batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_move_batch_item_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_move_batch_item_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data move batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_move_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataMoveBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data move batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_move_batch_items(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters | None = None) ‑> ProjectDataMoveBatchItemPagedList

Expand source code

@validate_call
def get_project_data_move_batch_items(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    project_data_move_batch_item_query_parameters: Optional[ProjectDataMoveBatchItemQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataMoveBatchItemPagedList:
    """Retrieve a list of project data move batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param project_data_move_batch_item_query_parameters:
    :type project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_move_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        project_data_move_batch_item_query_parameters=project_data_move_batch_item_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataMoveBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of project data move batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param project_data_move_batch_item_query_parameters: :type project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_move_batch_items_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters | None = None) ‑> ApiResponse[ProjectDataMoveBatchItemPagedList]

Expand source code

@validate_call
def get_project_data_move_batch_items_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    project_data_move_batch_item_query_parameters: Optional[ProjectDataMoveBatchItemQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataMoveBatchItemPagedList]:
    """Retrieve a list of project data move batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param project_data_move_batch_item_query_parameters:
    :type project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_move_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        project_data_move_batch_item_query_parameters=project_data_move_batch_item_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataMoveBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of project data move batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param project_data_move_batch_item_query_parameters: :type project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_move_batch_items_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_move_batch_items_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    project_data_move_batch_item_query_parameters: Optional[ProjectDataMoveBatchItemQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of project data move batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param project_data_move_batch_item_query_parameters:
    :type project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_move_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        project_data_move_batch_item_query_parameters=project_data_move_batch_item_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataMoveBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of project data move batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param project_data_move_batch_item_query_parameters: :type project_data_move_batch_item_query_parameters: ProjectDataMoveBatchItemQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_move_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataMoveBatch]

Expand source code

@validate_call
def get_project_data_move_batch_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataMoveBatch]:
    """Retrieve a project data move batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_move_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataMoveBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data move batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_move_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_move_batch_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data move batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_move_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataMoveBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data move batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectDataMoveBatchItem (**data: Any)

Expand source code

class ProjectDataMoveBatchItem(BaseModel):
    """
    ProjectDataMoveBatchItem
    """ # noqa: E501
    id: StrictStr
    request: ProjectDataMoveBatchItemRequest
    processing: ProjectDataMoveBatchItemProcessing
    created_project_data: Optional[ProjectData] = Field(default=None, alias="createdProjectData")
    __properties: ClassVar[List[str]] = ["id", "request", "processing", "createdProjectData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        # override the default output from pydantic by calling `to_dict()` of created_project_data
        if self.created_project_data:
            _dict['createdProjectData'] = self.created_project_data.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": ProjectDataMoveBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": ProjectDataMoveBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None,
            "createdProjectData": ProjectData.from_dict(obj["createdProjectData"]) if obj.get("createdProjectData") is not None else None
        })
        return _obj

ProjectDataMoveBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var created_project_data : ProjectData | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : ProjectDataMoveBatchItemProcessing

The type of the None singleton.

var request : ProjectDataMoveBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataMoveBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataMoveBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    # override the default output from pydantic by calling `to_dict()` of created_project_data
    if self.created_project_data:
        _dict['createdProjectData'] = self.created_project_data.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataMoveBatchItemPagedList (**data: Any)

Expand source code

class ProjectDataMoveBatchItemPagedList(BaseModel):
    """
    ProjectDataMoveBatchItemPagedList
    """ # noqa: E501
    items: List[ProjectDataMoveBatchItem]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItemPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItemPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectDataMoveBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

ProjectDataMoveBatchItemPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectDataMoveBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataMoveBatchItemPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataMoveBatchItemPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataMoveBatchItemProcessing (**data: Any)

Expand source code

class ProjectDataMoveBatchItemProcessing(BaseModel):
    """
    ProjectDataMoveBatchItemProcessing
    """ # noqa: E501
    status: StrictStr = Field(description="The status of the batch item. Possible values are: QUEUED, MOVING, MOVED, PARTIALLY_MOVED, FAILED. More statuses could be added in a future release.")
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItemProcessing from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItemProcessing from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

ProjectDataMoveBatchItemProcessing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataMoveBatchItemProcessing from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataMoveBatchItemProcessing from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataMoveBatchItemQueryParameters (**data: Any)

Expand source code

class ProjectDataMoveBatchItemQueryParameters(BaseModel):
    """
    ProjectDataMoveBatchItemQueryParameters
    """ # noqa: E501
    status: Optional[List[Optional[Annotated[str, Field(strict=True)]]]] = None
    __properties: ClassVar[List[str]] = ["status"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItemQueryParameters from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItemQueryParameters from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status")
        })
        return _obj

ProjectDataMoveBatchItemQueryParameters

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var status : List[str | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataMoveBatchItemQueryParameters from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataMoveBatchItemQueryParameters from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataMoveBatchItemRequest (**data: Any)

Expand source code

class ProjectDataMoveBatchItemRequest(BaseModel):
    """
    ProjectDataMoveBatchItemRequest
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItemRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataMoveBatchItemRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

ProjectDataMoveBatchItemRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataMoveBatchItemRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataMoveBatchItemRequest from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataPagedList (**data: Any)

Expand source code

class ProjectDataPagedList(BaseModel):
    """
    ProjectDataPagedList
    """ # noqa: E501
    items: List[ProjectData]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectData.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

ProjectDataPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectData]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataTransferApi (api_client=None)

Expand source code

class ProjectDataTransferApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def abort_data_transfer(
        self,
        project_id: StrictStr,
        data_transfer_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Abort a data transfer.

        Endpoint for aborting a data transfer.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_transfer_id: (required)
        :type data_transfer_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._abort_data_transfer_serialize(
            project_id=project_id,
            data_transfer_id=data_transfer_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def abort_data_transfer_with_http_info(
        self,
        project_id: StrictStr,
        data_transfer_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Abort a data transfer.

        Endpoint for aborting a data transfer.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_transfer_id: (required)
        :type data_transfer_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._abort_data_transfer_serialize(
            project_id=project_id,
            data_transfer_id=data_transfer_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def abort_data_transfer_without_preload_content(
        self,
        project_id: StrictStr,
        data_transfer_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Abort a data transfer.

        Endpoint for aborting a data transfer.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param data_transfer_id: (required)
        :type data_transfer_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._abort_data_transfer_serialize(
            project_id=project_id,
            data_transfer_id=data_transfer_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _abort_data_transfer_serialize(
        self,
        project_id,
        data_transfer_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_transfer_id is not None:
            _path_params['dataTransferId'] = data_transfer_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/dataTransfers/{dataTransferId}:abort',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_data_transfer(
        self,
        project_id: StrictStr,
        data_transfer_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DataTransfer:
        """Retrieve a data transfer.


        :param project_id: (required)
        :type project_id: str
        :param data_transfer_id: (required)
        :type data_transfer_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_transfer_serialize(
            project_id=project_id,
            data_transfer_id=data_transfer_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataTransfer",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_data_transfer_with_http_info(
        self,
        project_id: StrictStr,
        data_transfer_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DataTransfer]:
        """Retrieve a data transfer.


        :param project_id: (required)
        :type project_id: str
        :param data_transfer_id: (required)
        :type data_transfer_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_transfer_serialize(
            project_id=project_id,
            data_transfer_id=data_transfer_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataTransfer",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_data_transfer_without_preload_content(
        self,
        project_id: StrictStr,
        data_transfer_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a data transfer.


        :param project_id: (required)
        :type project_id: str
        :param data_transfer_id: (required)
        :type data_transfer_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_transfer_serialize(
            project_id=project_id,
            data_transfer_id=data_transfer_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataTransfer",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_data_transfer_serialize(
        self,
        project_id,
        data_transfer_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if data_transfer_id is not None:
            _path_params['dataTransferId'] = data_transfer_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataTransfers/{dataTransferId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_data_transfers(
        self,
        project_id: StrictStr,
        connector: Annotated[Optional[StrictStr], Field(description="The ID of the connector to filter on.")] = None,
        direction: Annotated[Optional[StrictStr], Field(description="The direction to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DataTransferPagedList:
        """Retrieve a list of data transfers.

        Retrieve a list of data transfers for the current app (session), excluding web browser transfers.

        :param project_id: (required)
        :type project_id: str
        :param connector: The ID of the connector to filter on.
        :type connector: str
        :param direction: The direction to filter on.
        :type direction: str
        :param status: The status to filter on.
        :type status: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_transfers_serialize(
            project_id=project_id,
            connector=connector,
            direction=direction,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataTransferPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_data_transfers_with_http_info(
        self,
        project_id: StrictStr,
        connector: Annotated[Optional[StrictStr], Field(description="The ID of the connector to filter on.")] = None,
        direction: Annotated[Optional[StrictStr], Field(description="The direction to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DataTransferPagedList]:
        """Retrieve a list of data transfers.

        Retrieve a list of data transfers for the current app (session), excluding web browser transfers.

        :param project_id: (required)
        :type project_id: str
        :param connector: The ID of the connector to filter on.
        :type connector: str
        :param direction: The direction to filter on.
        :type direction: str
        :param status: The status to filter on.
        :type status: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_transfers_serialize(
            project_id=project_id,
            connector=connector,
            direction=direction,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataTransferPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_data_transfers_without_preload_content(
        self,
        project_id: StrictStr,
        connector: Annotated[Optional[StrictStr], Field(description="The ID of the connector to filter on.")] = None,
        direction: Annotated[Optional[StrictStr], Field(description="The direction to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of data transfers.

        Retrieve a list of data transfers for the current app (session), excluding web browser transfers.

        :param project_id: (required)
        :type project_id: str
        :param connector: The ID of the connector to filter on.
        :type connector: str
        :param direction: The direction to filter on.
        :type direction: str
        :param status: The status to filter on.
        :type status: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_data_transfers_serialize(
            project_id=project_id,
            connector=connector,
            direction=direction,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataTransferPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_data_transfers_serialize(
        self,
        project_id,
        connector,
        direction,
        status,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if connector is not None:
            
            _query_params.append(('connector', connector))
            
        if direction is not None:
            
            _query_params.append(('direction', direction))
            
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataTransfers',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def abort_data_transfer(self,
project_id: Annotated[str, Strict(strict=True)],
data_transfer_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def abort_data_transfer(
    self,
    project_id: StrictStr,
    data_transfer_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Abort a data transfer.

    Endpoint for aborting a data transfer.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_transfer_id: (required)
    :type data_transfer_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._abort_data_transfer_serialize(
        project_id=project_id,
        data_transfer_id=data_transfer_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Abort a data transfer.

Endpoint for aborting a data transfer.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_transfer_id: (required) :type data_transfer_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def abort_data_transfer_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_transfer_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def abort_data_transfer_with_http_info(
    self,
    project_id: StrictStr,
    data_transfer_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Abort a data transfer.

    Endpoint for aborting a data transfer.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_transfer_id: (required)
    :type data_transfer_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._abort_data_transfer_serialize(
        project_id=project_id,
        data_transfer_id=data_transfer_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Abort a data transfer.

Endpoint for aborting a data transfer.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_transfer_id: (required) :type data_transfer_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def abort_data_transfer_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_transfer_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def abort_data_transfer_without_preload_content(
    self,
    project_id: StrictStr,
    data_transfer_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Abort a data transfer.

    Endpoint for aborting a data transfer.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param data_transfer_id: (required)
    :type data_transfer_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._abort_data_transfer_serialize(
        project_id=project_id,
        data_transfer_id=data_transfer_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Abort a data transfer.

Endpoint for aborting a data transfer.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param data_transfer_id: (required) :type data_transfer_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_transfer(self,
project_id: Annotated[str, Strict(strict=True)],
data_transfer_id: Annotated[str, Strict(strict=True)]) ‑> DataTransfer

Expand source code

@validate_call
def get_data_transfer(
    self,
    project_id: StrictStr,
    data_transfer_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DataTransfer:
    """Retrieve a data transfer.


    :param project_id: (required)
    :type project_id: str
    :param data_transfer_id: (required)
    :type data_transfer_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_transfer_serialize(
        project_id=project_id,
        data_transfer_id=data_transfer_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataTransfer",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a data transfer.

:param project_id: (required) :type project_id: str :param data_transfer_id: (required) :type data_transfer_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_transfer_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
data_transfer_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[DataTransfer]

Expand source code

@validate_call
def get_data_transfer_with_http_info(
    self,
    project_id: StrictStr,
    data_transfer_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DataTransfer]:
    """Retrieve a data transfer.


    :param project_id: (required)
    :type project_id: str
    :param data_transfer_id: (required)
    :type data_transfer_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_transfer_serialize(
        project_id=project_id,
        data_transfer_id=data_transfer_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataTransfer",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a data transfer.

:param project_id: (required) :type project_id: str :param data_transfer_id: (required) :type data_transfer_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_transfer_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
data_transfer_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_data_transfer_without_preload_content(
    self,
    project_id: StrictStr,
    data_transfer_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a data transfer.


    :param project_id: (required)
    :type project_id: str
    :param data_transfer_id: (required)
    :type data_transfer_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_transfer_serialize(
        project_id=project_id,
        data_transfer_id=data_transfer_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataTransfer",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a data transfer.

:param project_id: (required) :type project_id: str :param data_transfer_id: (required) :type data_transfer_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_transfers(self,
project_id: Annotated[str, Strict(strict=True)],
connector: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The ID of the connector to filter on.')] = None,
direction: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The direction to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration ')] = None) ‑> DataTransferPagedList

Expand source code

@validate_call
def get_data_transfers(
    self,
    project_id: StrictStr,
    connector: Annotated[Optional[StrictStr], Field(description="The ID of the connector to filter on.")] = None,
    direction: Annotated[Optional[StrictStr], Field(description="The direction to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DataTransferPagedList:
    """Retrieve a list of data transfers.

    Retrieve a list of data transfers for the current app (session), excluding web browser transfers.

    :param project_id: (required)
    :type project_id: str
    :param connector: The ID of the connector to filter on.
    :type connector: str
    :param direction: The direction to filter on.
    :type direction: str
    :param status: The status to filter on.
    :type status: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_transfers_serialize(
        project_id=project_id,
        connector=connector,
        direction=direction,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataTransferPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of data transfers.

Retrieve a list of data transfers for the current app (session), excluding web browser transfers.

:param project_id: (required) :type project_id: str :param connector: The ID of the connector to filter on. :type connector: str :param direction: The direction to filter on. :type direction: str :param status: The status to filter on. :type status: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_transfers_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
connector: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The ID of the connector to filter on.')] = None,
direction: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The direction to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration ')] = None) ‑> ApiResponse[DataTransferPagedList]

Expand source code

@validate_call
def get_data_transfers_with_http_info(
    self,
    project_id: StrictStr,
    connector: Annotated[Optional[StrictStr], Field(description="The ID of the connector to filter on.")] = None,
    direction: Annotated[Optional[StrictStr], Field(description="The direction to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DataTransferPagedList]:
    """Retrieve a list of data transfers.

    Retrieve a list of data transfers for the current app (session), excluding web browser transfers.

    :param project_id: (required)
    :type project_id: str
    :param connector: The ID of the connector to filter on.
    :type connector: str
    :param direction: The direction to filter on.
    :type direction: str
    :param status: The status to filter on.
    :type status: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_transfers_serialize(
        project_id=project_id,
        connector=connector,
        direction=direction,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataTransferPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of data transfers.

Retrieve a list of data transfers for the current app (session), excluding web browser transfers.

:param project_id: (required) :type project_id: str :param connector: The ID of the connector to filter on. :type connector: str :param direction: The direction to filter on. :type direction: str :param status: The status to filter on. :type status: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_data_transfers_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
connector: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The ID of the connector to filter on.')] = None,
direction: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The direction to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration ')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_data_transfers_without_preload_content(
    self,
    project_id: StrictStr,
    connector: Annotated[Optional[StrictStr], Field(description="The ID of the connector to filter on.")] = None,
    direction: Annotated[Optional[StrictStr], Field(description="The direction to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of data transfers.

    Retrieve a list of data transfers for the current app (session), excluding web browser transfers.

    :param project_id: (required)
    :type project_id: str
    :param connector: The ID of the connector to filter on.
    :type connector: str
    :param direction: The direction to filter on.
    :type direction: str
    :param status: The status to filter on.
    :type status: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_data_transfers_serialize(
        project_id=project_id,
        connector=connector,
        direction=direction,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataTransferPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of data transfers.

Retrieve a list of data transfers for the current app (session), excluding web browser transfers.

:param project_id: (required) :type project_id: str :param connector: The ID of the connector to filter on. :type connector: str :param direction: The direction to filter on. :type direction: str :param status: The status to filter on. :type status: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - direction - connector - protocol - dataTransferred - status - statusMessage - duration :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectDataUnlinkingBatch (**data: Any)

Expand source code

class ProjectDataUnlinkingBatch(BaseModel):
    """
    ProjectDataUnlinkingBatch
    """ # noqa: E501
    id: StrictStr
    job: Optional[Job]
    __properties: ClassVar[List[str]] = ["id", "job"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of job
        if self.job:
            _dict['job'] = self.job.to_dict()
        # set to None if job (nullable) is None
        # and model_fields_set contains the field
        if self.job is None and "job" in self.model_fields_set:
            _dict['job'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "job": Job.from_dict(obj["job"]) if obj.get("job") is not None else None
        })
        return _obj

ProjectDataUnlinkingBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var job : Job | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of job
    if self.job:
        _dict['job'] = self.job.to_dict()
    # set to None if job (nullable) is None
    # and model_fields_set contains the field
    if self.job is None and "job" in self.model_fields_set:
        _dict['job'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataUnlinkingBatchApi (api_client=None)

Expand source code

class ProjectDataUnlinkingBatchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_project_data_unlinking_batch(
        self,
        project_id: StrictStr,
        create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataUnlinkingBatch:
        """Create a project data unlinking batch.


        :param project_id: (required)
        :type project_id: str
        :param create_project_data_unlinking_batch: (required)
        :type create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_unlinking_batch_serialize(
            project_id=project_id,
            create_project_data_unlinking_batch=create_project_data_unlinking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_project_data_unlinking_batch_with_http_info(
        self,
        project_id: StrictStr,
        create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataUnlinkingBatch]:
        """Create a project data unlinking batch.


        :param project_id: (required)
        :type project_id: str
        :param create_project_data_unlinking_batch: (required)
        :type create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_unlinking_batch_serialize(
            project_id=project_id,
            create_project_data_unlinking_batch=create_project_data_unlinking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_project_data_unlinking_batch_without_preload_content(
        self,
        project_id: StrictStr,
        create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a project data unlinking batch.


        :param project_id: (required)
        :type project_id: str
        :param create_project_data_unlinking_batch: (required)
        :type create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_unlinking_batch_serialize(
            project_id=project_id,
            create_project_data_unlinking_batch=create_project_data_unlinking_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_project_data_unlinking_batch_serialize(
        self,
        project_id,
        create_project_data_unlinking_batch,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_project_data_unlinking_batch is not None:
            _body_params = create_project_data_unlinking_batch


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/dataUnlinkingBatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_unlinking_batch(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataUnlinkingBatch:
        """Retrieve a project data unlinking batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_unlinking_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_unlinking_batch_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataUnlinkingBatch]:
        """Retrieve a project data unlinking batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_unlinking_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_unlinking_batch_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data unlinking batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_unlinking_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUnlinkingBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_unlinking_batch_serialize(
        self,
        project_id,
        batch_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataUnlinkingBatch/{batchId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_unlinking_batch_item(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataUnlinkingBatchItem:
        """Retrieve a project data unlinking batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_unlinking_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUnlinkingBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_unlinking_batch_item_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataUnlinkingBatchItem]:
        """Retrieve a project data unlinking batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_unlinking_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUnlinkingBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_unlinking_batch_item_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data unlinking batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_unlinking_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUnlinkingBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_unlinking_batch_item_serialize(
        self,
        project_id,
        batch_id,
        item_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        if item_id is not None:
            _path_params['itemId'] = item_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataUnlinkingBatch/{batchId}/items/{itemId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_unlinking_batch_items(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataUnlinkingBatchItemPagedList:
        """Retrieve a list of project data unlinking batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_unlinking_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUnlinkingBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_unlinking_batch_items_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataUnlinkingBatchItemPagedList]:
        """Retrieve a list of project data unlinking batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_unlinking_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUnlinkingBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_unlinking_batch_items_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of project data unlinking batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_unlinking_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUnlinkingBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_unlinking_batch_items_serialize(
        self,
        project_id,
        batch_id,
        status,
        page_offset,
        page_token,
        page_size,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataUnlinkingBatch/{batchId}/items',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_project_data_unlinking_batch(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch) ‑> ProjectDataUnlinkingBatch

Expand source code

@validate_call
def create_project_data_unlinking_batch(
    self,
    project_id: StrictStr,
    create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataUnlinkingBatch:
    """Create a project data unlinking batch.


    :param project_id: (required)
    :type project_id: str
    :param create_project_data_unlinking_batch: (required)
    :type create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_unlinking_batch_serialize(
        project_id=project_id,
        create_project_data_unlinking_batch=create_project_data_unlinking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a project data unlinking batch.

:param project_id: (required) :type project_id: str :param create_project_data_unlinking_batch: (required) :type create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_unlinking_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch) ‑> ApiResponse[ProjectDataUnlinkingBatch]

Expand source code

@validate_call
def create_project_data_unlinking_batch_with_http_info(
    self,
    project_id: StrictStr,
    create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataUnlinkingBatch]:
    """Create a project data unlinking batch.


    :param project_id: (required)
    :type project_id: str
    :param create_project_data_unlinking_batch: (required)
    :type create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_unlinking_batch_serialize(
        project_id=project_id,
        create_project_data_unlinking_batch=create_project_data_unlinking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a project data unlinking batch.

:param project_id: (required) :type project_id: str :param create_project_data_unlinking_batch: (required) :type create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_unlinking_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_project_data_unlinking_batch_without_preload_content(
    self,
    project_id: StrictStr,
    create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a project data unlinking batch.


    :param project_id: (required)
    :type project_id: str
    :param create_project_data_unlinking_batch: (required)
    :type create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_unlinking_batch_serialize(
        project_id=project_id,
        create_project_data_unlinking_batch=create_project_data_unlinking_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a project data unlinking batch.

:param project_id: (required) :type project_id: str :param create_project_data_unlinking_batch: (required) :type create_project_data_unlinking_batch: CreateProjectDataUnlinkingBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_unlinking_batch(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataUnlinkingBatch

Expand source code

@validate_call
def get_project_data_unlinking_batch(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataUnlinkingBatch:
    """Retrieve a project data unlinking batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_unlinking_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data unlinking batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_unlinking_batch_item(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataUnlinkingBatchItem

Expand source code

@validate_call
def get_project_data_unlinking_batch_item(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataUnlinkingBatchItem:
    """Retrieve a project data unlinking batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_unlinking_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUnlinkingBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data unlinking batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_unlinking_batch_item_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataUnlinkingBatchItem]

Expand source code

@validate_call
def get_project_data_unlinking_batch_item_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataUnlinkingBatchItem]:
    """Retrieve a project data unlinking batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_unlinking_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUnlinkingBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data unlinking batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_unlinking_batch_item_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_unlinking_batch_item_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data unlinking batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_unlinking_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUnlinkingBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data unlinking batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_unlinking_batch_items(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ProjectDataUnlinkingBatchItemPagedList

Expand source code

@validate_call
def get_project_data_unlinking_batch_items(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataUnlinkingBatchItemPagedList:
    """Retrieve a list of project data unlinking batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_unlinking_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUnlinkingBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of project data unlinking batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_unlinking_batch_items_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ApiResponse[ProjectDataUnlinkingBatchItemPagedList]

Expand source code

@validate_call
def get_project_data_unlinking_batch_items_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataUnlinkingBatchItemPagedList]:
    """Retrieve a list of project data unlinking batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_unlinking_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUnlinkingBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of project data unlinking batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_unlinking_batch_items_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_unlinking_batch_items_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of project data unlinking batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_unlinking_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUnlinkingBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of project data unlinking batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_unlinking_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataUnlinkingBatch]

Expand source code

@validate_call
def get_project_data_unlinking_batch_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataUnlinkingBatch]:
    """Retrieve a project data unlinking batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_unlinking_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data unlinking batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_unlinking_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_unlinking_batch_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data unlinking batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_unlinking_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUnlinkingBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data unlinking batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectDataUnlinkingBatchItem (**data: Any)

Expand source code

class ProjectDataUnlinkingBatchItem(BaseModel):
    """
    ProjectDataUnlinkingBatchItem
    """ # noqa: E501
    id: StrictStr
    request: ProjectDataUnlinkingBatchItemRequest
    processing: ProjectDataUnlinkingBatchItemProcessing
    __properties: ClassVar[List[str]] = ["id", "request", "processing"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": ProjectDataUnlinkingBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": ProjectDataUnlinkingBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None
        })
        return _obj

ProjectDataUnlinkingBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : ProjectDataUnlinkingBatchItemProcessing

The type of the None singleton.

var request : ProjectDataUnlinkingBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataUnlinkingBatchItemPagedList (**data: Any)

Expand source code

class ProjectDataUnlinkingBatchItemPagedList(BaseModel):
    """
    ProjectDataUnlinkingBatchItemPagedList
    """ # noqa: E501
    items: List[ProjectDataUnlinkingBatchItem]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatchItemPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatchItemPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectDataUnlinkingBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

ProjectDataUnlinkingBatchItemPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectDataUnlinkingBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatchItemPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatchItemPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataUnlinkingBatchItemProcessing (**data: Any)

Expand source code

class ProjectDataUnlinkingBatchItemProcessing(BaseModel):
    """
    ProjectDataUnlinkingBatchItemProcessing
    """ # noqa: E501
    status: StrictStr = Field(description="Possible values are: INITIALISED, WAITING_RESOURCES, RUNNING, UNLINKED, ALREADY_UNLINKED, FAILED, PARTIALLY_UNLINKED. More types could be added in a future release.")
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatchItemProcessing from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatchItemProcessing from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

ProjectDataUnlinkingBatchItemProcessing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatchItemProcessing from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatchItemProcessing from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataUnlinkingBatchItemRequest (**data: Any)

Expand source code

class ProjectDataUnlinkingBatchItemRequest(BaseModel):
    """
    ProjectDataUnlinkingBatchItemRequest
    """ # noqa: E501
    data_id: StrictStr = Field(alias="dataId")
    __properties: ClassVar[List[str]] = ["dataId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatchItemRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUnlinkingBatchItemRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId")
        })
        return _obj

ProjectDataUnlinkingBatchItemRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatchItemRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUnlinkingBatchItemRequest from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataUpdateBatch (**data: Any)

Expand source code

class ProjectDataUpdateBatch(BaseModel):
    """
    ProjectDataUpdateBatch
    """ # noqa: E501
    id: StrictStr
    job: Optional[Job]
    __properties: ClassVar[List[str]] = ["id", "job"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of job
        if self.job:
            _dict['job'] = self.job.to_dict()
        # set to None if job (nullable) is None
        # and model_fields_set contains the field
        if self.job is None and "job" in self.model_fields_set:
            _dict['job'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "job": Job.from_dict(obj["job"]) if obj.get("job") is not None else None
        })
        return _obj

ProjectDataUpdateBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var job : Job | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUpdateBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUpdateBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of job
    if self.job:
        _dict['job'] = self.job.to_dict()
    # set to None if job (nullable) is None
    # and model_fields_set contains the field
    if self.job is None and "job" in self.model_fields_set:
        _dict['job'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataUpdateBatchApi (api_client=None)

Expand source code

class ProjectDataUpdateBatchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_project_data_update_batch(
        self,
        project_id: StrictStr,
        create_project_data_update_batch: CreateProjectDataUpdateBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataUpdateBatch:
        """Create a project data update batch.  Folder contents will be updated recursively.  Time archive/delete cannot be defined for folders.

        Avoid specifying more than 5000 total dataIds per call if possible (specifying more than 100000 is not allowed).

        :param project_id: (required)
        :type project_id: str
        :param create_project_data_update_batch: (required)
        :type create_project_data_update_batch: CreateProjectDataUpdateBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_update_batch_serialize(
            project_id=project_id,
            create_project_data_update_batch=create_project_data_update_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataUpdateBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_project_data_update_batch_with_http_info(
        self,
        project_id: StrictStr,
        create_project_data_update_batch: CreateProjectDataUpdateBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataUpdateBatch]:
        """Create a project data update batch.  Folder contents will be updated recursively.  Time archive/delete cannot be defined for folders.

        Avoid specifying more than 5000 total dataIds per call if possible (specifying more than 100000 is not allowed).

        :param project_id: (required)
        :type project_id: str
        :param create_project_data_update_batch: (required)
        :type create_project_data_update_batch: CreateProjectDataUpdateBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_update_batch_serialize(
            project_id=project_id,
            create_project_data_update_batch=create_project_data_update_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataUpdateBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_project_data_update_batch_without_preload_content(
        self,
        project_id: StrictStr,
        create_project_data_update_batch: CreateProjectDataUpdateBatch,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a project data update batch.  Folder contents will be updated recursively.  Time archive/delete cannot be defined for folders.

        Avoid specifying more than 5000 total dataIds per call if possible (specifying more than 100000 is not allowed).

        :param project_id: (required)
        :type project_id: str
        :param create_project_data_update_batch: (required)
        :type create_project_data_update_batch: CreateProjectDataUpdateBatch
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_data_update_batch_serialize(
            project_id=project_id,
            create_project_data_update_batch=create_project_data_update_batch,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectDataUpdateBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_project_data_update_batch_serialize(
        self,
        project_id,
        create_project_data_update_batch,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_project_data_update_batch is not None:
            _body_params = create_project_data_update_batch


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/dataUpdateBatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_update_batch(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataUpdateBatch:
        """Retrieve a project data update batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_update_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUpdateBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_update_batch_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataUpdateBatch]:
        """Retrieve a project data update batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_update_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUpdateBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_update_batch_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data update batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_update_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUpdateBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_update_batch_serialize(
        self,
        project_id,
        batch_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataUpdateBatch/{batchId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_update_batch_item(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataUpdateBatchItem:
        """Retrieve a project data update batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_update_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUpdateBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_update_batch_item_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataUpdateBatchItem]:
        """Retrieve a project data update batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_update_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUpdateBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_update_batch_item_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        item_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project data update batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param item_id: (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_update_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUpdateBatchItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_update_batch_item_serialize(
        self,
        project_id,
        batch_id,
        item_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        if item_id is not None:
            _path_params['itemId'] = item_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataUpdateBatch/{batchId}/items/{itemId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_data_update_batch_items(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectDataUpdateBatchItemPagedList:
        """Retrieve a list of project data update batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_update_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUpdateBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_data_update_batch_items_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectDataUpdateBatchItemPagedList]:
        """Retrieve a list of project data update batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_update_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUpdateBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_data_update_batch_items_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: StrictStr,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of project data update batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_data_update_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectDataUpdateBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_data_update_batch_items_serialize(
        self,
        project_id,
        batch_id,
        status,
        page_offset,
        page_token,
        page_size,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/dataUpdateBatch/{batchId}/items',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_project_data_update_batch(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_data_update_batch: CreateProjectDataUpdateBatch) ‑> ProjectDataUpdateBatch

Expand source code

@validate_call
def create_project_data_update_batch(
    self,
    project_id: StrictStr,
    create_project_data_update_batch: CreateProjectDataUpdateBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataUpdateBatch:
    """Create a project data update batch.  Folder contents will be updated recursively.  Time archive/delete cannot be defined for folders.

    Avoid specifying more than 5000 total dataIds per call if possible (specifying more than 100000 is not allowed).

    :param project_id: (required)
    :type project_id: str
    :param create_project_data_update_batch: (required)
    :type create_project_data_update_batch: CreateProjectDataUpdateBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_update_batch_serialize(
        project_id=project_id,
        create_project_data_update_batch=create_project_data_update_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataUpdateBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a project data update batch. Folder contents will be updated recursively. Time archive/delete cannot be defined for folders.

Avoid specifying more than 5000 total dataIds per call if possible (specifying more than 100000 is not allowed).

:param project_id: (required) :type project_id: str :param create_project_data_update_batch: (required) :type create_project_data_update_batch: CreateProjectDataUpdateBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_update_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_data_update_batch: CreateProjectDataUpdateBatch) ‑> ApiResponse[ProjectDataUpdateBatch]

Expand source code

@validate_call
def create_project_data_update_batch_with_http_info(
    self,
    project_id: StrictStr,
    create_project_data_update_batch: CreateProjectDataUpdateBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataUpdateBatch]:
    """Create a project data update batch.  Folder contents will be updated recursively.  Time archive/delete cannot be defined for folders.

    Avoid specifying more than 5000 total dataIds per call if possible (specifying more than 100000 is not allowed).

    :param project_id: (required)
    :type project_id: str
    :param create_project_data_update_batch: (required)
    :type create_project_data_update_batch: CreateProjectDataUpdateBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_update_batch_serialize(
        project_id=project_id,
        create_project_data_update_batch=create_project_data_update_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataUpdateBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a project data update batch. Folder contents will be updated recursively. Time archive/delete cannot be defined for folders.

Avoid specifying more than 5000 total dataIds per call if possible (specifying more than 100000 is not allowed).

:param project_id: (required) :type project_id: str :param create_project_data_update_batch: (required) :type create_project_data_update_batch: CreateProjectDataUpdateBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_data_update_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_data_update_batch: CreateProjectDataUpdateBatch) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_project_data_update_batch_without_preload_content(
    self,
    project_id: StrictStr,
    create_project_data_update_batch: CreateProjectDataUpdateBatch,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a project data update batch.  Folder contents will be updated recursively.  Time archive/delete cannot be defined for folders.

    Avoid specifying more than 5000 total dataIds per call if possible (specifying more than 100000 is not allowed).

    :param project_id: (required)
    :type project_id: str
    :param create_project_data_update_batch: (required)
    :type create_project_data_update_batch: CreateProjectDataUpdateBatch
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_data_update_batch_serialize(
        project_id=project_id,
        create_project_data_update_batch=create_project_data_update_batch,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectDataUpdateBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a project data update batch. Folder contents will be updated recursively. Time archive/delete cannot be defined for folders.

Avoid specifying more than 5000 total dataIds per call if possible (specifying more than 100000 is not allowed).

:param project_id: (required) :type project_id: str :param create_project_data_update_batch: (required) :type create_project_data_update_batch: CreateProjectDataUpdateBatch :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_update_batch(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataUpdateBatch

Expand source code

@validate_call
def get_project_data_update_batch(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataUpdateBatch:
    """Retrieve a project data update batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_update_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUpdateBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data update batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_update_batch_item(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ProjectDataUpdateBatchItem

Expand source code

@validate_call
def get_project_data_update_batch_item(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataUpdateBatchItem:
    """Retrieve a project data update batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_update_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUpdateBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project data update batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_update_batch_item_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataUpdateBatchItem]

Expand source code

@validate_call
def get_project_data_update_batch_item_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataUpdateBatchItem]:
    """Retrieve a project data update batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_update_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUpdateBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data update batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_update_batch_item_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
item_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_update_batch_item_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    item_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data update batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param item_id: (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_update_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUpdateBatchItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data update batch item.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param item_id: (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_update_batch_items(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ProjectDataUpdateBatchItemPagedList

Expand source code

@validate_call
def get_project_data_update_batch_items(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectDataUpdateBatchItemPagedList:
    """Retrieve a list of project data update batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_update_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUpdateBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of project data update batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_update_batch_items_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ApiResponse[ProjectDataUpdateBatchItemPagedList]

Expand source code

@validate_call
def get_project_data_update_batch_items_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataUpdateBatchItemPagedList]:
    """Retrieve a list of project data update batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_update_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUpdateBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of project data update batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_update_batch_items_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_update_batch_items_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of project data update batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_update_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUpdateBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of project data update batch items.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_update_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectDataUpdateBatch]

Expand source code

@validate_call
def get_project_data_update_batch_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectDataUpdateBatch]:
    """Retrieve a project data update batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_update_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUpdateBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project data update batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_data_update_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_data_update_batch_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project data update batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_data_update_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectDataUpdateBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project data update batch.

:param project_id: (required) :type project_id: str :param batch_id: (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectDataUpdateBatchItem (**data: Any)

Expand source code

class ProjectDataUpdateBatchItem(BaseModel):
    """
    ProjectDataUpdateBatchItem
    """ # noqa: E501
    id: StrictStr
    request: ProjectDataUpdateBatchItemRequest
    processing: ProjectDataUpdateBatchItemProcessing
    __properties: ClassVar[List[str]] = ["id", "request", "processing"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatchItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatchItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": ProjectDataUpdateBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": ProjectDataUpdateBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None
        })
        return _obj

ProjectDataUpdateBatchItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : ProjectDataUpdateBatchItemProcessing

The type of the None singleton.

var request : ProjectDataUpdateBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUpdateBatchItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUpdateBatchItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataUpdateBatchItemPagedList (**data: Any)

Expand source code

class ProjectDataUpdateBatchItemPagedList(BaseModel):
    """
    ProjectDataUpdateBatchItemPagedList
    """ # noqa: E501
    items: List[ProjectDataUpdateBatchItem]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatchItemPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatchItemPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectDataUpdateBatchItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

ProjectDataUpdateBatchItemPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectDataUpdateBatchItem]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUpdateBatchItemPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUpdateBatchItemPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataUpdateBatchItemProcessing (**data: Any)

Expand source code

class ProjectDataUpdateBatchItemProcessing(BaseModel):
    """
    ProjectDataUpdateBatchItemProcessing
    """ # noqa: E501
    status: StrictStr
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['INITIALISED', 'WAITING_RESOURCES', 'UPDATING', 'UPDATED', 'PARTIALLY_UPDATED', 'FAILED']):
            raise ValueError("must be one of enum values ('INITIALISED', 'WAITING_RESOURCES', 'UPDATING', 'UPDATED', 'PARTIALLY_UPDATED', 'FAILED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatchItemProcessing from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatchItemProcessing from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

ProjectDataUpdateBatchItemProcessing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUpdateBatchItemProcessing from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUpdateBatchItemProcessing from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectDataUpdateBatchItemRequest (**data: Any)

Expand source code

class ProjectDataUpdateBatchItemRequest(BaseModel):
    """
    ProjectDataUpdateBatchItemRequest
    """ # noqa: E501
    data_id: StrictStr = Field(description="Data to apply the update to (recursively, if it's a folder).", alias="dataId")
    user_tags: Optional[TagUpdate] = Field(default=None, alias="userTags")
    technical_tags: Optional[TagUpdate] = Field(default=None, alias="technicalTags")
    will_be_archived_at: Optional[datetime] = Field(default=None, description="The timestamp when the data should be archived.", alias="willBeArchivedAt")
    will_be_deleted_at: Optional[datetime] = Field(default=None, description="The timestamp when the data should be deleted.", alias="willBeDeletedAt")
    __properties: ClassVar[List[str]] = ["dataId", "userTags", "technicalTags", "willBeArchivedAt", "willBeDeletedAt"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatchItemRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of user_tags
        if self.user_tags:
            _dict['userTags'] = self.user_tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of technical_tags
        if self.technical_tags:
            _dict['technicalTags'] = self.technical_tags.to_dict()
        # set to None if user_tags (nullable) is None
        # and model_fields_set contains the field
        if self.user_tags is None and "user_tags" in self.model_fields_set:
            _dict['userTags'] = None

        # set to None if technical_tags (nullable) is None
        # and model_fields_set contains the field
        if self.technical_tags is None and "technical_tags" in self.model_fields_set:
            _dict['technicalTags'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectDataUpdateBatchItemRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId"),
            "userTags": TagUpdate.from_dict(obj["userTags"]) if obj.get("userTags") is not None else None,
            "technicalTags": TagUpdate.from_dict(obj["technicalTags"]) if obj.get("technicalTags") is not None else None,
            "willBeArchivedAt": obj.get("willBeArchivedAt"),
            "willBeDeletedAt": obj.get("willBeDeletedAt")
        })
        return _obj

ProjectDataUpdateBatchItemRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var technical_tags : TagUpdate | None

The type of the None singleton.

var user_tags : TagUpdate | None

The type of the None singleton.

var will_be_archived_at : datetime.datetime | None

The type of the None singleton.

var will_be_deleted_at : datetime.datetime | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectDataUpdateBatchItemRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectDataUpdateBatchItemRequest from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of user_tags
    if self.user_tags:
        _dict['userTags'] = self.user_tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of technical_tags
    if self.technical_tags:
        _dict['technicalTags'] = self.technical_tags.to_dict()
    # set to None if user_tags (nullable) is None
    # and model_fields_set contains the field
    if self.user_tags is None and "user_tags" in self.model_fields_set:
        _dict['userTags'] = None

    # set to None if technical_tags (nullable) is None
    # and model_fields_set contains the field
    if self.technical_tags is None and "technical_tags" in self.model_fields_set:
        _dict['technicalTags'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectFileAndUploadUrl (**data: Any)

Expand source code

class ProjectFileAndUploadUrl(BaseModel):
    """
    ProjectFileAndUploadUrl
    """ # noqa: E501
    data: Data
    project_id: StrictStr = Field(alias="projectId")
    upload_url: StrictStr = Field(description="A pre-signed url which is temporarily available for uploading the data.", alias="uploadUrl")
    __properties: ClassVar[List[str]] = ["data", "projectId", "uploadUrl"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectFileAndUploadUrl from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of data
        if self.data:
            _dict['data'] = self.data.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectFileAndUploadUrl from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "data": Data.from_dict(obj["data"]) if obj.get("data") is not None else None,
            "projectId": obj.get("projectId"),
            "uploadUrl": obj.get("uploadUrl")
        })
        return _obj

ProjectFileAndUploadUrl

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data : Data

The type of the None singleton.

var model_config

The type of the None singleton.

var project_id : str

The type of the None singleton.

var upload_url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectFileAndUploadUrl from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectFileAndUploadUrl from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of data
    if self.data:
        _dict['data'] = self.data.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectFolderAndUploadSession (**data: Any)

Expand source code

class ProjectFolderAndUploadSession(BaseModel):
    """
    ProjectFolderAndUploadSession
    """ # noqa: E501
    data: Data
    project_id: StrictStr = Field(alias="projectId")
    upload_session: FolderUploadSession = Field(alias="uploadSession")
    __properties: ClassVar[List[str]] = ["data", "projectId", "uploadSession"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectFolderAndUploadSession from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of data
        if self.data:
            _dict['data'] = self.data.to_dict()
        # override the default output from pydantic by calling `to_dict()` of upload_session
        if self.upload_session:
            _dict['uploadSession'] = self.upload_session.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectFolderAndUploadSession from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "data": Data.from_dict(obj["data"]) if obj.get("data") is not None else None,
            "projectId": obj.get("projectId"),
            "uploadSession": FolderUploadSession.from_dict(obj["uploadSession"]) if obj.get("uploadSession") is not None else None
        })
        return _obj

ProjectFolderAndUploadSession

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data : Data

The type of the None singleton.

var model_config

The type of the None singleton.

var project_id : str

The type of the None singleton.

var upload_session : FolderUploadSession

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectFolderAndUploadSession from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectFolderAndUploadSession from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of data
    if self.data:
        _dict['data'] = self.data.to_dict()
    # override the default output from pydantic by calling `to_dict()` of upload_session
    if self.upload_session:
        _dict['uploadSession'] = self.upload_session.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectList (**data: Any)

Expand source code

class ProjectList(BaseModel):
    """
    ProjectList
    """ # noqa: E501
    items: List[Project]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Project.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ProjectList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Project]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectNotificationSubscriptionsApi (api_client=None)

Expand source code

class ProjectNotificationSubscriptionsApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_notification_subscription(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        create_notification_subscription: Annotated[CreateNotificationSubscription, Field(description="The new subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationSubscription:
        """Create a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param create_notification_subscription: The new subscription (required)
        :type create_notification_subscription: CreateNotificationSubscription
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_notification_subscription_serialize(
            project_id=project_id,
            create_notification_subscription=create_notification_subscription,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_notification_subscription_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        create_notification_subscription: Annotated[CreateNotificationSubscription, Field(description="The new subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationSubscription]:
        """Create a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param create_notification_subscription: The new subscription (required)
        :type create_notification_subscription: CreateNotificationSubscription
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_notification_subscription_serialize(
            project_id=project_id,
            create_notification_subscription=create_notification_subscription,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_notification_subscription_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        create_notification_subscription: Annotated[CreateNotificationSubscription, Field(description="The new subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param create_notification_subscription: The new subscription (required)
        :type create_notification_subscription: CreateNotificationSubscription
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_notification_subscription_serialize(
            project_id=project_id,
            create_notification_subscription=create_notification_subscription,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_notification_subscription_serialize(
        self,
        project_id,
        create_notification_subscription,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_notification_subscription is not None:
            _body_params = create_notification_subscription


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/notificationSubscriptions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_notification_subscription(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to delete")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription to delete (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_notification_subscription_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to delete")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription to delete (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_notification_subscription_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to delete")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription to delete (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_notification_subscription_serialize(
        self,
        project_id,
        subscription_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if subscription_id is not None:
            _path_params['subscriptionId'] = subscription_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/projects/{projectId}/notificationSubscriptions/{subscriptionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_notification_subscription(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationSubscription:
        """Retrieve a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_notification_subscription_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationSubscription]:
        """Retrieve a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_notification_subscription_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a notification subscription


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription (required)
        :type subscription_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_notification_subscription_serialize(
        self,
        project_id,
        subscription_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if subscription_id is not None:
            _path_params['subscriptionId'] = subscription_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/notificationSubscriptions/{subscriptionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_notification_subscriptions(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationSubscriptionList:
        """Retrieve notification subscriptions


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_subscriptions_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscriptionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_notification_subscriptions_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationSubscriptionList]:
        """Retrieve notification subscriptions


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_subscriptions_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscriptionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_notification_subscriptions_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve notification subscriptions


        :param project_id: The ID of the project (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_notification_subscriptions_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscriptionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_notification_subscriptions_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/notificationSubscriptions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_notification_subscription(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to update")],
        notification_subscription: Annotated[NotificationSubscription, Field(description="The updated subscription")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> NotificationSubscription:
        """Update a notification subscription

        Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription to update (required)
        :type subscription_id: str
        :param notification_subscription: The updated subscription (required)
        :type notification_subscription: NotificationSubscription
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            notification_subscription=notification_subscription,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_notification_subscription_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to update")],
        notification_subscription: Annotated[NotificationSubscription, Field(description="The updated subscription")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[NotificationSubscription]:
        """Update a notification subscription

        Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription to update (required)
        :type subscription_id: str
        :param notification_subscription: The updated subscription (required)
        :type notification_subscription: NotificationSubscription
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            notification_subscription=notification_subscription,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_notification_subscription_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project")],
        subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to update")],
        notification_subscription: Annotated[NotificationSubscription, Field(description="The updated subscription")],
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a notification subscription

        Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

        :param project_id: The ID of the project (required)
        :type project_id: str
        :param subscription_id: The ID of the notification subscription to update (required)
        :type subscription_id: str
        :param notification_subscription: The updated subscription (required)
        :type notification_subscription: NotificationSubscription
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_notification_subscription_serialize(
            project_id=project_id,
            subscription_id=subscription_id,
            notification_subscription=notification_subscription,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "NotificationSubscription",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_notification_subscription_serialize(
        self,
        project_id,
        subscription_id,
        notification_subscription,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if subscription_id is not None:
            _path_params['subscriptionId'] = subscription_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if notification_subscription is not None:
            _body_params = notification_subscription


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/notificationSubscriptions/{subscriptionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_notification_subscription(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
create_notification_subscription: Annotated[CreateNotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The new subscription')]) ‑> NotificationSubscription

Expand source code

@validate_call
def create_notification_subscription(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    create_notification_subscription: Annotated[CreateNotificationSubscription, Field(description="The new subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> NotificationSubscription:
    """Create a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param create_notification_subscription: The new subscription (required)
    :type create_notification_subscription: CreateNotificationSubscription
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_notification_subscription_serialize(
        project_id=project_id,
        create_notification_subscription=create_notification_subscription,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param create_notification_subscription: The new subscription (required) :type create_notification_subscription: CreateNotificationSubscription :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_notification_subscription_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
create_notification_subscription: Annotated[CreateNotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The new subscription')]) ‑> ApiResponse[NotificationSubscription]

Expand source code

@validate_call
def create_notification_subscription_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    create_notification_subscription: Annotated[CreateNotificationSubscription, Field(description="The new subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[NotificationSubscription]:
    """Create a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param create_notification_subscription: The new subscription (required)
    :type create_notification_subscription: CreateNotificationSubscription
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_notification_subscription_serialize(
        project_id=project_id,
        create_notification_subscription=create_notification_subscription,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param create_notification_subscription: The new subscription (required) :type create_notification_subscription: CreateNotificationSubscription :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_notification_subscription_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
create_notification_subscription: Annotated[CreateNotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The new subscription')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_notification_subscription_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    create_notification_subscription: Annotated[CreateNotificationSubscription, Field(description="The new subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param create_notification_subscription: The new subscription (required)
    :type create_notification_subscription: CreateNotificationSubscription
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_notification_subscription_serialize(
        project_id=project_id,
        create_notification_subscription=create_notification_subscription,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param create_notification_subscription: The new subscription (required) :type create_notification_subscription: CreateNotificationSubscription :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_notification_subscription(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription to delete')]) ‑> None

Expand source code

@validate_call
def delete_notification_subscription(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to delete")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription to delete (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription to delete (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_notification_subscription_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription to delete')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_notification_subscription_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to delete")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription to delete (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription to delete (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_notification_subscription_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription to delete')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_notification_subscription_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to delete")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription to delete (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription to delete (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_subscription(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription')]) ‑> NotificationSubscription

Expand source code

@validate_call
def get_notification_subscription(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> NotificationSubscription:
    """Retrieve a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_subscription_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription')]) ‑> ApiResponse[NotificationSubscription]

Expand source code

@validate_call
def get_notification_subscription_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[NotificationSubscription]:
    """Retrieve a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_subscription_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_notification_subscription_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a notification subscription


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription (required)
    :type subscription_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a notification subscription

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription (required) :type subscription_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_subscriptions(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')]) ‑> NotificationSubscriptionList

Expand source code

@validate_call
def get_notification_subscriptions(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> NotificationSubscriptionList:
    """Retrieve notification subscriptions


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_subscriptions_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscriptionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve notification subscriptions

:param project_id: The ID of the project (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_subscriptions_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')]) ‑> ApiResponse[NotificationSubscriptionList]

Expand source code

@validate_call
def get_notification_subscriptions_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[NotificationSubscriptionList]:
    """Retrieve notification subscriptions


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_subscriptions_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscriptionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve notification subscriptions

:param project_id: The ID of the project (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_notification_subscriptions_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_notification_subscriptions_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve notification subscriptions


    :param project_id: The ID of the project (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_notification_subscriptions_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscriptionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve notification subscriptions

:param project_id: The ID of the project (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_notification_subscription(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription to update')],
notification_subscription: Annotated[NotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The updated subscription')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> NotificationSubscription

Expand source code

@validate_call
def update_notification_subscription(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to update")],
    notification_subscription: Annotated[NotificationSubscription, Field(description="The updated subscription")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> NotificationSubscription:
    """Update a notification subscription

    Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription to update (required)
    :type subscription_id: str
    :param notification_subscription: The updated subscription (required)
    :type notification_subscription: NotificationSubscription
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        notification_subscription=notification_subscription,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update a notification subscription

Fields which can be updated: - enabled - eventCode - filterExpression - notificationChannel

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription to update (required) :type subscription_id: str :param notification_subscription: The updated subscription (required) :type notification_subscription: NotificationSubscription :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_notification_subscription_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription to update')],
notification_subscription: Annotated[NotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The updated subscription')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[NotificationSubscription]

Expand source code

@validate_call
def update_notification_subscription_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to update")],
    notification_subscription: Annotated[NotificationSubscription, Field(description="The updated subscription")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[NotificationSubscription]:
    """Update a notification subscription

    Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription to update (required)
    :type subscription_id: str
    :param notification_subscription: The updated subscription (required)
    :type notification_subscription: NotificationSubscription
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        notification_subscription=notification_subscription,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update a notification subscription

Fields which can be updated: - enabled - eventCode - filterExpression - notificationChannel

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription to update (required) :type subscription_id: str :param notification_subscription: The updated subscription (required) :type notification_subscription: NotificationSubscription :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_notification_subscription_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project')],
subscription_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the notification subscription to update')],
notification_subscription: Annotated[NotificationSubscription, FieldInfo(annotation=NoneType, required=True, description='The updated subscription')],
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_notification_subscription_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project")],
    subscription_id: Annotated[StrictStr, Field(description="The ID of the notification subscription to update")],
    notification_subscription: Annotated[NotificationSubscription, Field(description="The updated subscription")],
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update a notification subscription

    Fields which can be updated:  - enabled  - eventCode  - filterExpression  - notificationChannel 

    :param project_id: The ID of the project (required)
    :type project_id: str
    :param subscription_id: The ID of the notification subscription to update (required)
    :type subscription_id: str
    :param notification_subscription: The updated subscription (required)
    :type notification_subscription: NotificationSubscription
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_notification_subscription_serialize(
        project_id=project_id,
        subscription_id=subscription_id,
        notification_subscription=notification_subscription,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "NotificationSubscription",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update a notification subscription

Fields which can be updated: - enabled - eventCode - filterExpression - notificationChannel

:param project_id: The ID of the project (required) :type project_id: str :param subscription_id: The ID of the notification subscription to update (required) :type subscription_id: str :param notification_subscription: The updated subscription (required) :type notification_subscription: NotificationSubscription :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectPagedList (**data: Any)

Expand source code

class ProjectPagedList(BaseModel):
    """
    ProjectPagedList
    """ # noqa: E501
    items: List[Project]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Project.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

ProjectPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Project]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectPermission (**data: Any)

Expand source code

class ProjectPermission(BaseModel):
    """
    ProjectPermission
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    role_project: StrictStr = Field(alias="roleProject")
    role_flow: StrictStr = Field(alias="roleFlow")
    role_base: StrictStr = Field(alias="roleBase")
    role_bench: StrictStr = Field(alias="roleBench")
    membership_type: StrictStr = Field(alias="membershipType")
    user: Optional[User] = None
    email_address: Optional[StrictStr] = Field(default=None, description="Only present when membershipType is EMAIL", alias="emailAddress")
    workgroup: Optional[Workgroup] = None
    invitation_accepted: Optional[StrictBool] = Field(default=None, description="Only present when membershipType is EMAIL", alias="invitationAccepted")
    invitation_rejected: Optional[StrictBool] = Field(default=None, description="Only present when user is invited by EMAIL", alias="invitationRejected")
    upload_allowed: StrictBool = Field(alias="uploadAllowed")
    download_allowed: StrictBool = Field(alias="downloadAllowed")
    application: Optional[ApplicationV4] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "roleProject", "roleFlow", "roleBase", "roleBench", "membershipType", "user", "emailAddress", "workgroup", "invitationAccepted", "invitationRejected", "uploadAllowed", "downloadAllowed", "application"]

    @field_validator('role_project')
    def role_project_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['NONE', 'VIEWER', 'CONTRIBUTOR', 'ADMINISTRATOR', 'DATA_PROVIDER']):
            raise ValueError("must be one of enum values ('NONE', 'VIEWER', 'CONTRIBUTOR', 'ADMINISTRATOR', 'DATA_PROVIDER')")
        return value

    @field_validator('role_flow')
    def role_flow_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['NONE', 'VIEWER', 'CONTRIBUTOR']):
            raise ValueError("must be one of enum values ('NONE', 'VIEWER', 'CONTRIBUTOR')")
        return value

    @field_validator('role_base')
    def role_base_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['NONE', 'VIEWER', 'CONTRIBUTOR']):
            raise ValueError("must be one of enum values ('NONE', 'VIEWER', 'CONTRIBUTOR')")
        return value

    @field_validator('role_bench')
    def role_bench_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['NONE', 'CONTRIBUTOR']):
            raise ValueError("must be one of enum values ('NONE', 'CONTRIBUTOR')")
        return value

    @field_validator('membership_type')
    def membership_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['USER', 'EMAIL', 'WORKGROUP']):
            raise ValueError("must be one of enum values ('USER', 'EMAIL', 'WORKGROUP')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectPermission from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of user
        if self.user:
            _dict['user'] = self.user.to_dict()
        # override the default output from pydantic by calling `to_dict()` of workgroup
        if self.workgroup:
            _dict['workgroup'] = self.workgroup.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if email_address (nullable) is None
        # and model_fields_set contains the field
        if self.email_address is None and "email_address" in self.model_fields_set:
            _dict['emailAddress'] = None

        # set to None if invitation_accepted (nullable) is None
        # and model_fields_set contains the field
        if self.invitation_accepted is None and "invitation_accepted" in self.model_fields_set:
            _dict['invitationAccepted'] = None

        # set to None if invitation_rejected (nullable) is None
        # and model_fields_set contains the field
        if self.invitation_rejected is None and "invitation_rejected" in self.model_fields_set:
            _dict['invitationRejected'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectPermission from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "roleProject": obj.get("roleProject"),
            "roleFlow": obj.get("roleFlow"),
            "roleBase": obj.get("roleBase"),
            "roleBench": obj.get("roleBench"),
            "membershipType": obj.get("membershipType"),
            "user": User.from_dict(obj["user"]) if obj.get("user") is not None else None,
            "emailAddress": obj.get("emailAddress"),
            "workgroup": Workgroup.from_dict(obj["workgroup"]) if obj.get("workgroup") is not None else None,
            "invitationAccepted": obj.get("invitationAccepted"),
            "invitationRejected": obj.get("invitationRejected"),
            "uploadAllowed": obj.get("uploadAllowed"),
            "downloadAllowed": obj.get("downloadAllowed"),
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None
        })
        return _obj

ProjectPermission

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var application : ApplicationV4 | None

The type of the None singleton.

var download_allowed : bool

The type of the None singleton.

var email_address : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var invitation_accepted : bool | None

The type of the None singleton.

var invitation_rejected : bool | None

The type of the None singleton.

var membership_type : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var role_base : str

The type of the None singleton.

var role_bench : str

The type of the None singleton.

var role_flow : str

The type of the None singleton.

var role_project : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var upload_allowed : bool

The type of the None singleton.

var user : User | None

The type of the None singleton.

var workgroup : Workgroup | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectPermission from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectPermission from a JSON string

def membership_type_validate_enum(value)

Validates the enum

def role_base_validate_enum(value)

Validates the enum

def role_bench_validate_enum(value)

Validates the enum

def role_flow_validate_enum(value)

Validates the enum

def role_project_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of user
    if self.user:
        _dict['user'] = self.user.to_dict()
    # override the default output from pydantic by calling `to_dict()` of workgroup
    if self.workgroup:
        _dict['workgroup'] = self.workgroup.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if email_address (nullable) is None
    # and model_fields_set contains the field
    if self.email_address is None and "email_address" in self.model_fields_set:
        _dict['emailAddress'] = None

    # set to None if invitation_accepted (nullable) is None
    # and model_fields_set contains the field
    if self.invitation_accepted is None and "invitation_accepted" in self.model_fields_set:
        _dict['invitationAccepted'] = None

    # set to None if invitation_rejected (nullable) is None
    # and model_fields_set contains the field
    if self.invitation_rejected is None and "invitation_rejected" in self.model_fields_set:
        _dict['invitationRejected'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectPermissionApi (api_client=None)

Expand source code

class ProjectPermissionApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_project_permission(
        self,
        project_id: StrictStr,
        create_project_permission_v4: CreateProjectPermissionV4,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPermissionV4:
        """Create a project permission.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

        :param project_id: (required)
        :type project_id: str
        :param create_project_permission_v4: (required)
        :type create_project_permission_v4: CreateProjectPermissionV4
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_permission_serialize(
            project_id=project_id,
            create_project_permission_v4=create_project_permission_v4,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPermissionV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_project_permission_with_http_info(
        self,
        project_id: StrictStr,
        create_project_permission_v4: CreateProjectPermissionV4,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPermissionV4]:
        """Create a project permission.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

        :param project_id: (required)
        :type project_id: str
        :param create_project_permission_v4: (required)
        :type create_project_permission_v4: CreateProjectPermissionV4
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_permission_serialize(
            project_id=project_id,
            create_project_permission_v4=create_project_permission_v4,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPermissionV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_project_permission_without_preload_content(
        self,
        project_id: StrictStr,
        create_project_permission_v4: CreateProjectPermissionV4,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a project permission.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

        :param project_id: (required)
        :type project_id: str
        :param create_project_permission_v4: (required)
        :type create_project_permission_v4: CreateProjectPermissionV4
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_permission_serialize(
            project_id=project_id,
            create_project_permission_v4=create_project_permission_v4,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPermissionV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_project_permission_serialize(
        self,
        project_id,
        create_project_permission_v4,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_project_permission_v4 is not None:
            _body_params = create_project_permission_v4


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json', 
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/permissions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_permission(
        self,
        project_id: StrictStr,
        permission_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPermissionV4:
        """Retrieve a project permission.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

        :param project_id: (required)
        :type project_id: str
        :param permission_id: (required)
        :type permission_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_permission_serialize(
            project_id=project_id,
            permission_id=permission_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPermissionV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_permission_with_http_info(
        self,
        project_id: StrictStr,
        permission_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPermissionV4]:
        """Retrieve a project permission.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

        :param project_id: (required)
        :type project_id: str
        :param permission_id: (required)
        :type permission_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_permission_serialize(
            project_id=project_id,
            permission_id=permission_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPermissionV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_permission_without_preload_content(
        self,
        project_id: StrictStr,
        permission_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project permission.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

        :param project_id: (required)
        :type project_id: str
        :param permission_id: (required)
        :type permission_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_permission_serialize(
            project_id=project_id,
            permission_id=permission_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPermissionV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_permission_serialize(
        self,
        project_id,
        permission_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if permission_id is not None:
            _path_params['permissionId'] = permission_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/permissions/{permissionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_permissions(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPermissionListV4:
        """Retrieve a list of project permissions.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_permissions_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPermissionListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_permissions_with_http_info(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPermissionListV4]:
        """Retrieve a list of project permissions.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_permissions_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPermissionListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_permissions_without_preload_content(
        self,
        project_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of project permissions.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

        :param project_id: (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_permissions_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPermissionListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_permissions_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/permissions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_project_permission(
        self,
        project_id: StrictStr,
        permission_id: StrictStr,
        project_permission_v4: ProjectPermissionV4,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPermissionV4:
        """Update a project permission.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. Fields which can be updated: - uploadAllowed - downloadAllowed - roleProject - roleFlow - roleBase - roleBench

        :param project_id: (required)
        :type project_id: str
        :param permission_id: (required)
        :type permission_id: str
        :param project_permission_v4: (required)
        :type project_permission_v4: ProjectPermissionV4
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_permission_serialize(
            project_id=project_id,
            permission_id=permission_id,
            project_permission_v4=project_permission_v4,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPermissionV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_project_permission_with_http_info(
        self,
        project_id: StrictStr,
        permission_id: StrictStr,
        project_permission_v4: ProjectPermissionV4,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPermissionV4]:
        """Update a project permission.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. Fields which can be updated: - uploadAllowed - downloadAllowed - roleProject - roleFlow - roleBase - roleBench

        :param project_id: (required)
        :type project_id: str
        :param permission_id: (required)
        :type permission_id: str
        :param project_permission_v4: (required)
        :type project_permission_v4: ProjectPermissionV4
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_permission_serialize(
            project_id=project_id,
            permission_id=permission_id,
            project_permission_v4=project_permission_v4,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPermissionV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_project_permission_without_preload_content(
        self,
        project_id: StrictStr,
        permission_id: StrictStr,
        project_permission_v4: ProjectPermissionV4,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a project permission.

        # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. Fields which can be updated: - uploadAllowed - downloadAllowed - roleProject - roleFlow - roleBase - roleBench

        :param project_id: (required)
        :type project_id: str
        :param permission_id: (required)
        :type permission_id: str
        :param project_permission_v4: (required)
        :type project_permission_v4: ProjectPermissionV4
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_permission_serialize(
            project_id=project_id,
            permission_id=permission_id,
            project_permission_v4=project_permission_v4,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPermissionV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_project_permission_serialize(
        self,
        project_id,
        permission_id,
        project_permission_v4,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if permission_id is not None:
            _path_params['permissionId'] = permission_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if project_permission_v4 is not None:
            _body_params = project_permission_v4


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json', 
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/permissions/{permissionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_project_permission(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_permission_v4: CreateProjectPermissionV4) ‑> ProjectPermissionV4

Expand source code

@validate_call
def create_project_permission(
    self,
    project_id: StrictStr,
    create_project_permission_v4: CreateProjectPermissionV4,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPermissionV4:
    """Create a project permission.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

    :param project_id: (required)
    :type project_id: str
    :param create_project_permission_v4: (required)
    :type create_project_permission_v4: CreateProjectPermissionV4
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_permission_serialize(
        project_id=project_id,
        create_project_permission_v4=create_project_permission_v4,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPermissionV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a project permission.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner.

:param project_id: (required) :type project_id: str :param create_project_permission_v4: (required) :type create_project_permission_v4: CreateProjectPermissionV4 :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_permission_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_permission_v4: CreateProjectPermissionV4) ‑> ApiResponse[ProjectPermissionV4]

Expand source code

@validate_call
def create_project_permission_with_http_info(
    self,
    project_id: StrictStr,
    create_project_permission_v4: CreateProjectPermissionV4,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPermissionV4]:
    """Create a project permission.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

    :param project_id: (required)
    :type project_id: str
    :param create_project_permission_v4: (required)
    :type create_project_permission_v4: CreateProjectPermissionV4
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_permission_serialize(
        project_id=project_id,
        create_project_permission_v4=create_project_permission_v4,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPermissionV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a project permission.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner.

:param project_id: (required) :type project_id: str :param create_project_permission_v4: (required) :type create_project_permission_v4: CreateProjectPermissionV4 :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_permission_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_project_permission_v4: CreateProjectPermissionV4) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_project_permission_without_preload_content(
    self,
    project_id: StrictStr,
    create_project_permission_v4: CreateProjectPermissionV4,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a project permission.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

    :param project_id: (required)
    :type project_id: str
    :param create_project_permission_v4: (required)
    :type create_project_permission_v4: CreateProjectPermissionV4
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_permission_serialize(
        project_id=project_id,
        create_project_permission_v4=create_project_permission_v4,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPermissionV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a project permission.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner.

:param project_id: (required) :type project_id: str :param create_project_permission_v4: (required) :type create_project_permission_v4: CreateProjectPermissionV4 :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_permission(self,
project_id: Annotated[str, Strict(strict=True)],
permission_id: Annotated[str, Strict(strict=True)]) ‑> ProjectPermissionV4

Expand source code

@validate_call
def get_project_permission(
    self,
    project_id: StrictStr,
    permission_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPermissionV4:
    """Retrieve a project permission.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

    :param project_id: (required)
    :type project_id: str
    :param permission_id: (required)
    :type permission_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_permission_serialize(
        project_id=project_id,
        permission_id=permission_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPermissionV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project permission.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner.

:param project_id: (required) :type project_id: str :param permission_id: (required) :type permission_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_permission_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
permission_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectPermissionV4]

Expand source code

@validate_call
def get_project_permission_with_http_info(
    self,
    project_id: StrictStr,
    permission_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPermissionV4]:
    """Retrieve a project permission.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

    :param project_id: (required)
    :type project_id: str
    :param permission_id: (required)
    :type permission_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_permission_serialize(
        project_id=project_id,
        permission_id=permission_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPermissionV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project permission.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner.

:param project_id: (required) :type project_id: str :param permission_id: (required) :type permission_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_permission_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
permission_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_permission_without_preload_content(
    self,
    project_id: StrictStr,
    permission_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project permission.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

    :param project_id: (required)
    :type project_id: str
    :param permission_id: (required)
    :type permission_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_permission_serialize(
        project_id=project_id,
        permission_id=permission_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPermissionV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project permission.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner.

:param project_id: (required) :type project_id: str :param permission_id: (required) :type permission_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_permissions(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ProjectPermissionListV4

Expand source code

@validate_call
def get_project_permissions(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPermissionListV4:
    """Retrieve a list of project permissions.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_permissions_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPermissionListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of project permissions.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_permissions_with_http_info(self, project_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectPermissionListV4]

Expand source code

@validate_call
def get_project_permissions_with_http_info(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPermissionListV4]:
    """Retrieve a list of project permissions.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_permissions_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPermissionListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of project permissions.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_permissions_without_preload_content(self, project_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_permissions_without_preload_content(
    self,
    project_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of project permissions.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. 

    :param project_id: (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_permissions_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPermissionListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of project permissions.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner.

:param project_id: (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_permission(self,
project_id: Annotated[str, Strict(strict=True)],
permission_id: Annotated[str, Strict(strict=True)],
project_permission_v4: ProjectPermissionV4,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ProjectPermissionV4

Expand source code

@validate_call
def update_project_permission(
    self,
    project_id: StrictStr,
    permission_id: StrictStr,
    project_permission_v4: ProjectPermissionV4,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPermissionV4:
    """Update a project permission.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. Fields which can be updated: - uploadAllowed - downloadAllowed - roleProject - roleFlow - roleBase - roleBench

    :param project_id: (required)
    :type project_id: str
    :param permission_id: (required)
    :type permission_id: str
    :param project_permission_v4: (required)
    :type project_permission_v4: ProjectPermissionV4
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_permission_serialize(
        project_id=project_id,
        permission_id=permission_id,
        project_permission_v4=project_permission_v4,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPermissionV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update a project permission.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. Fields which can be updated: - uploadAllowed - downloadAllowed - roleProject - roleFlow - roleBase - roleBench

:param project_id: (required) :type project_id: str :param permission_id: (required) :type permission_id: str :param project_permission_v4: (required) :type project_permission_v4: ProjectPermissionV4 :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_permission_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
permission_id: Annotated[str, Strict(strict=True)],
project_permission_v4: ProjectPermissionV4,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[ProjectPermissionV4]

Expand source code

@validate_call
def update_project_permission_with_http_info(
    self,
    project_id: StrictStr,
    permission_id: StrictStr,
    project_permission_v4: ProjectPermissionV4,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPermissionV4]:
    """Update a project permission.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. Fields which can be updated: - uploadAllowed - downloadAllowed - roleProject - roleFlow - roleBase - roleBench

    :param project_id: (required)
    :type project_id: str
    :param permission_id: (required)
    :type permission_id: str
    :param project_permission_v4: (required)
    :type project_permission_v4: ProjectPermissionV4
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_permission_serialize(
        project_id=project_id,
        permission_id=permission_id,
        project_permission_v4=project_permission_v4,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPermissionV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update a project permission.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. Fields which can be updated: - uploadAllowed - downloadAllowed - roleProject - roleFlow - roleBase - roleBench

:param project_id: (required) :type project_id: str :param permission_id: (required) :type permission_id: str :param project_permission_v4: (required) :type project_permission_v4: ProjectPermissionV4 :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_permission_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
permission_id: Annotated[str, Strict(strict=True)],
project_permission_v4: ProjectPermissionV4,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_project_permission_without_preload_content(
    self,
    project_id: StrictStr,
    permission_id: StrictStr,
    project_permission_v4: ProjectPermissionV4,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update a project permission.

    # Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version.  ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. Fields which can be updated: - uploadAllowed - downloadAllowed - roleProject - roleFlow - roleBase - roleBench

    :param project_id: (required)
    :type project_id: str
    :param permission_id: (required)
    :type permission_id: str
    :param project_permission_v4: (required)
    :type project_permission_v4: ProjectPermissionV4
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_permission_serialize(
        project_id=project_id,
        permission_id=permission_id,
        project_permission_v4=project_permission_v4,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPermissionV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update a project permission.

Changelog For this endpoint multiple versions exist. Note that the values for request headers 'Content-Type' and 'Accept' must contain a matching version. ## [V3] Initial version ## [V4] Added 'Administrator' role for Bench. The role attributes are strings instead of enums to support future additions in a backward compatible manner. Fields which can be updated: - uploadAllowed - downloadAllowed - roleProject - roleFlow - roleBase - roleBench

:param project_id: (required) :type project_id: str :param permission_id: (required) :type permission_id: str :param project_permission_v4: (required) :type project_permission_v4: ProjectPermissionV4 :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectPermissionList (**data: Any)

Expand source code

class ProjectPermissionList(BaseModel):
    """
    ProjectPermissionList
    """ # noqa: E501
    items: List[ProjectPermission]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectPermissionList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectPermissionList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectPermission.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ProjectPermissionList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectPermission]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectPermissionList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectPermissionList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectPermissionListV4 (**data: Any)

Expand source code

class ProjectPermissionListV4(BaseModel):
    """
    ProjectPermissionListV4
    """ # noqa: E501
    items: List[ProjectPermissionV4]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectPermissionListV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectPermissionListV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectPermissionV4.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ProjectPermissionListV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectPermissionV4]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectPermissionListV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectPermissionListV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectPermissionV4 (**data: Any)

Expand source code

class ProjectPermissionV4(BaseModel):
    """
    ProjectPermissionV4
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    role_project: StrictStr = Field(description="Possible values are: NONE, VIEWER, CONTRIBUTOR, ADMINISTRATOR, DATA_PROVIDER. More types could be added in a future release.", alias="roleProject")
    role_flow: StrictStr = Field(description="Possible values are: NONE, VIEWER, CONTRIBUTOR. More types could be added in a future release.", alias="roleFlow")
    role_base: StrictStr = Field(description="Possible values are: NONE, VIEWER, CONTRIBUTOR. More types could be added in a future release.", alias="roleBase")
    role_bench: StrictStr = Field(description="Possible values are: NONE, CONTRIBUTOR, ADMINISTRATOR. More types could be added in a future release.", alias="roleBench")
    membership_type: StrictStr = Field(alias="membershipType")
    user: Optional[User] = None
    email_address: Optional[StrictStr] = Field(default=None, description="Only present when membershipType is EMAIL", alias="emailAddress")
    workgroup: Optional[Workgroup] = None
    invitation_accepted: Optional[StrictBool] = Field(default=None, description="Only present when membershipType is EMAIL", alias="invitationAccepted")
    invitation_rejected: Optional[StrictBool] = Field(default=None, description="Only present when user is invited by EMAIL", alias="invitationRejected")
    upload_allowed: StrictBool = Field(alias="uploadAllowed")
    download_allowed: StrictBool = Field(alias="downloadAllowed")
    application: Optional[ApplicationV4] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "roleProject", "roleFlow", "roleBase", "roleBench", "membershipType", "user", "emailAddress", "workgroup", "invitationAccepted", "invitationRejected", "uploadAllowed", "downloadAllowed", "application"]

    @field_validator('membership_type')
    def membership_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['USER', 'EMAIL', 'WORKGROUP']):
            raise ValueError("must be one of enum values ('USER', 'EMAIL', 'WORKGROUP')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectPermissionV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of user
        if self.user:
            _dict['user'] = self.user.to_dict()
        # override the default output from pydantic by calling `to_dict()` of workgroup
        if self.workgroup:
            _dict['workgroup'] = self.workgroup.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if email_address (nullable) is None
        # and model_fields_set contains the field
        if self.email_address is None and "email_address" in self.model_fields_set:
            _dict['emailAddress'] = None

        # set to None if invitation_accepted (nullable) is None
        # and model_fields_set contains the field
        if self.invitation_accepted is None and "invitation_accepted" in self.model_fields_set:
            _dict['invitationAccepted'] = None

        # set to None if invitation_rejected (nullable) is None
        # and model_fields_set contains the field
        if self.invitation_rejected is None and "invitation_rejected" in self.model_fields_set:
            _dict['invitationRejected'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectPermissionV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "roleProject": obj.get("roleProject"),
            "roleFlow": obj.get("roleFlow"),
            "roleBase": obj.get("roleBase"),
            "roleBench": obj.get("roleBench"),
            "membershipType": obj.get("membershipType"),
            "user": User.from_dict(obj["user"]) if obj.get("user") is not None else None,
            "emailAddress": obj.get("emailAddress"),
            "workgroup": Workgroup.from_dict(obj["workgroup"]) if obj.get("workgroup") is not None else None,
            "invitationAccepted": obj.get("invitationAccepted"),
            "invitationRejected": obj.get("invitationRejected"),
            "uploadAllowed": obj.get("uploadAllowed"),
            "downloadAllowed": obj.get("downloadAllowed"),
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None
        })
        return _obj

ProjectPermissionV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var application : ApplicationV4 | None

The type of the None singleton.

var download_allowed : bool

The type of the None singleton.

var email_address : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var invitation_accepted : bool | None

The type of the None singleton.

var invitation_rejected : bool | None

The type of the None singleton.

var membership_type : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var role_base : str

The type of the None singleton.

var role_bench : str

The type of the None singleton.

var role_flow : str

The type of the None singleton.

var role_project : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var upload_allowed : bool

The type of the None singleton.

var user : User | None

The type of the None singleton.

var workgroup : Workgroup | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectPermissionV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectPermissionV4 from a JSON string

def membership_type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of user
    if self.user:
        _dict['user'] = self.user.to_dict()
    # override the default output from pydantic by calling `to_dict()` of workgroup
    if self.workgroup:
        _dict['workgroup'] = self.workgroup.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if email_address (nullable) is None
    # and model_fields_set contains the field
    if self.email_address is None and "email_address" in self.model_fields_set:
        _dict['emailAddress'] = None

    # set to None if invitation_accepted (nullable) is None
    # and model_fields_set contains the field
    if self.invitation_accepted is None and "invitation_accepted" in self.model_fields_set:
        _dict['invitationAccepted'] = None

    # set to None if invitation_rejected (nullable) is None
    # and model_fields_set contains the field
    if self.invitation_rejected is None and "invitation_rejected" in self.model_fields_set:
        _dict['invitationRejected'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectPipeline (**data: Any)

Expand source code

class ProjectPipeline(BaseModel):
    """
    ProjectPipeline
    """ # noqa: E501
    pipeline: PipelineV3
    project_id: StrictStr = Field(alias="projectId")
    bundle_links: BundleList = Field(alias="bundleLinks")
    __properties: ClassVar[List[str]] = ["pipeline", "projectId", "bundleLinks"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectPipeline from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of pipeline
        if self.pipeline:
            _dict['pipeline'] = self.pipeline.to_dict()
        # override the default output from pydantic by calling `to_dict()` of bundle_links
        if self.bundle_links:
            _dict['bundleLinks'] = self.bundle_links.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectPipeline from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "pipeline": PipelineV3.from_dict(obj["pipeline"]) if obj.get("pipeline") is not None else None,
            "projectId": obj.get("projectId"),
            "bundleLinks": BundleList.from_dict(obj["bundleLinks"]) if obj.get("bundleLinks") is not None else None
        })
        return _obj

ProjectPipeline

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bundle_links : BundleList

The type of the None singleton.

var model_config

The type of the None singleton.

var pipeline : PipelineV3

The type of the None singleton.

var project_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectPipeline from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectPipeline from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of pipeline
    if self.pipeline:
        _dict['pipeline'] = self.pipeline.to_dict()
    # override the default output from pydantic by calling `to_dict()` of bundle_links
    if self.bundle_links:
        _dict['bundleLinks'] = self.bundle_links.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectPipelineApi (api_client=None)

Expand source code

class ProjectPipelineApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_additional_project_pipeline_file(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineFile:
        """Create an additional input form file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to create a file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_additional_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "PipelineFile",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_additional_project_pipeline_file_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineFile]:
        """Create an additional input form file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to create a file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_additional_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "PipelineFile",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_additional_project_pipeline_file_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create an additional input form file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to create a file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_additional_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "PipelineFile",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_additional_project_pipeline_file_serialize(
        self,
        project_id,
        pipeline_id,
        content,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if content is not None:
            _files['content'] = content
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/additionalFiles',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_cwl_json_pipeline(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
        workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
        input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
        on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
        other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPipelineV4:
        """Create a JSON based CWL pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the CWL pipeline (required)
        :type code: str
        :param description: The description of the CWL pipeline (required)
        :type description: str
        :param workflow_cwl_file: The CWL workflow file. (required)
        :type workflow_cwl_file: bytearray
        :param input_form_file: The JSON based input form. (required)
        :type input_form_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param tool_cwl_files:
        :type tool_cwl_files: List[bytearray]
        :param on_render_file: A file that will render the current state of the input form.
        :type on_render_file: bytearray
        :param on_submit_file: A file that will submit the current state of the input form.
        :type on_submit_file: bytearray
        :param other_input_form_files:
        :type other_input_form_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_json_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            workflow_cwl_file=workflow_cwl_file,
            input_form_file=input_form_file,
            analysis_storage_id=analysis_storage_id,
            tool_cwl_files=tool_cwl_files,
            on_render_file=on_render_file,
            on_submit_file=on_submit_file,
            other_input_form_files=other_input_form_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_cwl_json_pipeline_with_http_info(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
        workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
        input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
        on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
        other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPipelineV4]:
        """Create a JSON based CWL pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the CWL pipeline (required)
        :type code: str
        :param description: The description of the CWL pipeline (required)
        :type description: str
        :param workflow_cwl_file: The CWL workflow file. (required)
        :type workflow_cwl_file: bytearray
        :param input_form_file: The JSON based input form. (required)
        :type input_form_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param tool_cwl_files:
        :type tool_cwl_files: List[bytearray]
        :param on_render_file: A file that will render the current state of the input form.
        :type on_render_file: bytearray
        :param on_submit_file: A file that will submit the current state of the input form.
        :type on_submit_file: bytearray
        :param other_input_form_files:
        :type other_input_form_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_json_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            workflow_cwl_file=workflow_cwl_file,
            input_form_file=input_form_file,
            analysis_storage_id=analysis_storage_id,
            tool_cwl_files=tool_cwl_files,
            on_render_file=on_render_file,
            on_submit_file=on_submit_file,
            other_input_form_files=other_input_form_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_cwl_json_pipeline_without_preload_content(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
        workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
        input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
        on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
        other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a JSON based CWL pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the CWL pipeline (required)
        :type code: str
        :param description: The description of the CWL pipeline (required)
        :type description: str
        :param workflow_cwl_file: The CWL workflow file. (required)
        :type workflow_cwl_file: bytearray
        :param input_form_file: The JSON based input form. (required)
        :type input_form_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param tool_cwl_files:
        :type tool_cwl_files: List[bytearray]
        :param on_render_file: A file that will render the current state of the input form.
        :type on_render_file: bytearray
        :param on_submit_file: A file that will submit the current state of the input form.
        :type on_submit_file: bytearray
        :param other_input_form_files:
        :type other_input_form_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_json_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            workflow_cwl_file=workflow_cwl_file,
            input_form_file=input_form_file,
            analysis_storage_id=analysis_storage_id,
            tool_cwl_files=tool_cwl_files,
            on_render_file=on_render_file,
            on_submit_file=on_submit_file,
            other_input_form_files=other_input_form_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_cwl_json_pipeline_serialize(
        self,
        project_id,
        code,
        description,
        workflow_cwl_file,
        input_form_file,
        analysis_storage_id,
        tool_cwl_files,
        on_render_file,
        on_submit_file,
        other_input_form_files,
        metadata_model_file,
        links,
        version_comment,
        categories,
        html_documentation,
        proprietary,
        report_configs,
        resources,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'toolCwlFiles': 'csv',
            'otherInputFormFiles': 'csv',
            'categories': 'csv',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if code is not None:
            _form_params.append(('code', code))
        if description is not None:
            _form_params.append(('description', description))
        if workflow_cwl_file is not None:
            _files['workflowCwlFile'] = workflow_cwl_file
        if tool_cwl_files is not None:
            _files['toolCwlFiles'] = tool_cwl_files
        if input_form_file is not None:
            _files['inputFormFile'] = input_form_file
        if on_render_file is not None:
            _files['onRenderFile'] = on_render_file
        if on_submit_file is not None:
            _files['onSubmitFile'] = on_submit_file
        if other_input_form_files is not None:
            _files['otherInputFormFiles'] = other_input_form_files
        if metadata_model_file is not None:
            _files['metadataModelFile'] = metadata_model_file
        if links is not None:
            _form_params.append(('links', links))
        if version_comment is not None:
            _form_params.append(('versionComment', version_comment))
        if categories is not None:
            _form_params.append(('categories', categories))
        if html_documentation is not None:
            _form_params.append(('htmlDocumentation', html_documentation))
        if analysis_storage_id is not None:
            _form_params.append(('analysisStorageId', analysis_storage_id))
        if proprietary is not None:
            _form_params.append(('proprietary', proprietary))
        if report_configs is not None:
            _form_params.append(('reportConfigs', report_configs))
        if resources is not None:
            _form_params.append(('resources', resources))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/pipelines:createCwlJsonPipeline',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_cwl_pipeline(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
        workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
        parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPipeline:
        """Create a CWL pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the CWL pipeline (required)
        :type code: str
        :param description: The description of the CWL pipeline (required)
        :type description: str
        :param workflow_cwl_file: The CWL workflow file. (required)
        :type workflow_cwl_file: bytearray
        :param parameters_xml_file: (required)
        :type parameters_xml_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param tool_cwl_files:
        :type tool_cwl_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            workflow_cwl_file=workflow_cwl_file,
            parameters_xml_file=parameters_xml_file,
            analysis_storage_id=analysis_storage_id,
            tool_cwl_files=tool_cwl_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPipeline",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_cwl_pipeline_with_http_info(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
        workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
        parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPipeline]:
        """Create a CWL pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the CWL pipeline (required)
        :type code: str
        :param description: The description of the CWL pipeline (required)
        :type description: str
        :param workflow_cwl_file: The CWL workflow file. (required)
        :type workflow_cwl_file: bytearray
        :param parameters_xml_file: (required)
        :type parameters_xml_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param tool_cwl_files:
        :type tool_cwl_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            workflow_cwl_file=workflow_cwl_file,
            parameters_xml_file=parameters_xml_file,
            analysis_storage_id=analysis_storage_id,
            tool_cwl_files=tool_cwl_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPipeline",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_cwl_pipeline_without_preload_content(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
        workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
        parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a CWL pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the CWL pipeline (required)
        :type code: str
        :param description: The description of the CWL pipeline (required)
        :type description: str
        :param workflow_cwl_file: The CWL workflow file. (required)
        :type workflow_cwl_file: bytearray
        :param parameters_xml_file: (required)
        :type parameters_xml_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param tool_cwl_files:
        :type tool_cwl_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_cwl_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            workflow_cwl_file=workflow_cwl_file,
            parameters_xml_file=parameters_xml_file,
            analysis_storage_id=analysis_storage_id,
            tool_cwl_files=tool_cwl_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPipeline",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_cwl_pipeline_serialize(
        self,
        project_id,
        code,
        description,
        workflow_cwl_file,
        parameters_xml_file,
        analysis_storage_id,
        tool_cwl_files,
        metadata_model_file,
        links,
        version_comment,
        categories,
        html_documentation,
        proprietary,
        report_configs,
        resources,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'toolCwlFiles': 'csv',
            'categories': 'csv',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if code is not None:
            _form_params.append(('code', code))
        if description is not None:
            _form_params.append(('description', description))
        if workflow_cwl_file is not None:
            _files['workflowCwlFile'] = workflow_cwl_file
        if tool_cwl_files is not None:
            _files['toolCwlFiles'] = tool_cwl_files
        if parameters_xml_file is not None:
            _files['parametersXmlFile'] = parameters_xml_file
        if metadata_model_file is not None:
            _files['metadataModelFile'] = metadata_model_file
        if links is not None:
            _form_params.append(('links', links))
        if version_comment is not None:
            _form_params.append(('versionComment', version_comment))
        if categories is not None:
            _form_params.append(('categories', categories))
        if html_documentation is not None:
            _form_params.append(('htmlDocumentation', html_documentation))
        if analysis_storage_id is not None:
            _form_params.append(('analysisStorageId', analysis_storage_id))
        if proprietary is not None:
            _form_params.append(('proprietary', proprietary))
        if report_configs is not None:
            _form_params.append(('reportConfigs', report_configs))
        if resources is not None:
            _form_params.append(('resources', resources))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/pipelines:createCwlPipeline',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_nextflow_json_pipeline(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
        main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
        input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
        nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
        other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
        on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
        other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineV4:
        """Create a JSON based Nextflow pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the pipeline (required)
        :type code: str
        :param description: The description of the pipeline (required)
        :type description: str
        :param main_nextflow_file: The main Nextflow file. (required)
        :type main_nextflow_file: bytearray
        :param input_form_file: The JSON based input form. (required)
        :type input_form_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
        :type pipeline_language_version_id: str
        :param nextflow_config_file: The Nextflow config file.
        :type nextflow_config_file: bytearray
        :param other_nextflow_files:
        :type other_nextflow_files: List[bytearray]
        :param on_render_file: A file that will render the current state of the input form.
        :type on_render_file: bytearray
        :param on_submit_file: A file that will submit the current state of the input form.
        :type on_submit_file: bytearray
        :param other_input_form_files:
        :type other_input_form_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_json_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            main_nextflow_file=main_nextflow_file,
            input_form_file=input_form_file,
            analysis_storage_id=analysis_storage_id,
            pipeline_language_version_id=pipeline_language_version_id,
            nextflow_config_file=nextflow_config_file,
            other_nextflow_files=other_nextflow_files,
            on_render_file=on_render_file,
            on_submit_file=on_submit_file,
            other_input_form_files=other_input_form_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "PipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_nextflow_json_pipeline_with_http_info(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
        main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
        input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
        nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
        other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
        on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
        other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineV4]:
        """Create a JSON based Nextflow pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the pipeline (required)
        :type code: str
        :param description: The description of the pipeline (required)
        :type description: str
        :param main_nextflow_file: The main Nextflow file. (required)
        :type main_nextflow_file: bytearray
        :param input_form_file: The JSON based input form. (required)
        :type input_form_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
        :type pipeline_language_version_id: str
        :param nextflow_config_file: The Nextflow config file.
        :type nextflow_config_file: bytearray
        :param other_nextflow_files:
        :type other_nextflow_files: List[bytearray]
        :param on_render_file: A file that will render the current state of the input form.
        :type on_render_file: bytearray
        :param on_submit_file: A file that will submit the current state of the input form.
        :type on_submit_file: bytearray
        :param other_input_form_files:
        :type other_input_form_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_json_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            main_nextflow_file=main_nextflow_file,
            input_form_file=input_form_file,
            analysis_storage_id=analysis_storage_id,
            pipeline_language_version_id=pipeline_language_version_id,
            nextflow_config_file=nextflow_config_file,
            other_nextflow_files=other_nextflow_files,
            on_render_file=on_render_file,
            on_submit_file=on_submit_file,
            other_input_form_files=other_input_form_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "PipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_nextflow_json_pipeline_without_preload_content(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
        main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
        input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
        nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
        other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
        on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
        other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a JSON based Nextflow pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the pipeline (required)
        :type code: str
        :param description: The description of the pipeline (required)
        :type description: str
        :param main_nextflow_file: The main Nextflow file. (required)
        :type main_nextflow_file: bytearray
        :param input_form_file: The JSON based input form. (required)
        :type input_form_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
        :type pipeline_language_version_id: str
        :param nextflow_config_file: The Nextflow config file.
        :type nextflow_config_file: bytearray
        :param other_nextflow_files:
        :type other_nextflow_files: List[bytearray]
        :param on_render_file: A file that will render the current state of the input form.
        :type on_render_file: bytearray
        :param on_submit_file: A file that will submit the current state of the input form.
        :type on_submit_file: bytearray
        :param other_input_form_files:
        :type other_input_form_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_json_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            main_nextflow_file=main_nextflow_file,
            input_form_file=input_form_file,
            analysis_storage_id=analysis_storage_id,
            pipeline_language_version_id=pipeline_language_version_id,
            nextflow_config_file=nextflow_config_file,
            other_nextflow_files=other_nextflow_files,
            on_render_file=on_render_file,
            on_submit_file=on_submit_file,
            other_input_form_files=other_input_form_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "PipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_nextflow_json_pipeline_serialize(
        self,
        project_id,
        code,
        description,
        main_nextflow_file,
        input_form_file,
        analysis_storage_id,
        pipeline_language_version_id,
        nextflow_config_file,
        other_nextflow_files,
        on_render_file,
        on_submit_file,
        other_input_form_files,
        metadata_model_file,
        links,
        version_comment,
        categories,
        html_documentation,
        proprietary,
        report_configs,
        resources,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'otherNextflowFiles': 'csv',
            'otherInputFormFiles': 'csv',
            'categories': 'csv',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if code is not None:
            _form_params.append(('code', code))
        if pipeline_language_version_id is not None:
            _form_params.append(('pipelineLanguageVersionId', pipeline_language_version_id))
        if description is not None:
            _form_params.append(('description', description))
        if main_nextflow_file is not None:
            _files['mainNextflowFile'] = main_nextflow_file
        if nextflow_config_file is not None:
            _files['nextflowConfigFile'] = nextflow_config_file
        if other_nextflow_files is not None:
            _files['otherNextflowFiles'] = other_nextflow_files
        if input_form_file is not None:
            _files['inputFormFile'] = input_form_file
        if on_render_file is not None:
            _files['onRenderFile'] = on_render_file
        if on_submit_file is not None:
            _files['onSubmitFile'] = on_submit_file
        if other_input_form_files is not None:
            _files['otherInputFormFiles'] = other_input_form_files
        if metadata_model_file is not None:
            _files['metadataModelFile'] = metadata_model_file
        if links is not None:
            _form_params.append(('links', links))
        if version_comment is not None:
            _form_params.append(('versionComment', version_comment))
        if categories is not None:
            _form_params.append(('categories', categories))
        if html_documentation is not None:
            _form_params.append(('htmlDocumentation', html_documentation))
        if analysis_storage_id is not None:
            _form_params.append(('analysisStorageId', analysis_storage_id))
        if proprietary is not None:
            _form_params.append(('proprietary', proprietary))
        if report_configs is not None:
            _form_params.append(('reportConfigs', report_configs))
        if resources is not None:
            _form_params.append(('resources', resources))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/pipelines:createNextflowJsonPipeline',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_nextflow_pipeline(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
        main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
        parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
        nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
        other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPipeline:
        """Create a Nextflow pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the pipeline (required)
        :type code: str
        :param description: The description of the pipeline (required)
        :type description: str
        :param main_nextflow_file: The main Nextflow file. (required)
        :type main_nextflow_file: bytearray
        :param parameters_xml_file: (required)
        :type parameters_xml_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
        :type pipeline_language_version_id: str
        :param nextflow_config_file: The Nextflow config file.
        :type nextflow_config_file: bytearray
        :param other_nextflow_files:
        :type other_nextflow_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            main_nextflow_file=main_nextflow_file,
            parameters_xml_file=parameters_xml_file,
            analysis_storage_id=analysis_storage_id,
            pipeline_language_version_id=pipeline_language_version_id,
            nextflow_config_file=nextflow_config_file,
            other_nextflow_files=other_nextflow_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPipeline",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_nextflow_pipeline_with_http_info(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
        main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
        parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
        nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
        other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPipeline]:
        """Create a Nextflow pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the pipeline (required)
        :type code: str
        :param description: The description of the pipeline (required)
        :type description: str
        :param main_nextflow_file: The main Nextflow file. (required)
        :type main_nextflow_file: bytearray
        :param parameters_xml_file: (required)
        :type parameters_xml_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
        :type pipeline_language_version_id: str
        :param nextflow_config_file: The Nextflow config file.
        :type nextflow_config_file: bytearray
        :param other_nextflow_files:
        :type other_nextflow_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            main_nextflow_file=main_nextflow_file,
            parameters_xml_file=parameters_xml_file,
            analysis_storage_id=analysis_storage_id,
            pipeline_language_version_id=pipeline_language_version_id,
            nextflow_config_file=nextflow_config_file,
            other_nextflow_files=other_nextflow_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPipeline",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_nextflow_pipeline_without_preload_content(
        self,
        project_id: StrictStr,
        code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
        description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
        main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
        parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
        pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
        nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
        other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
        metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
        links: Optional[Links] = None,
        version_comment: Optional[StrictStr] = None,
        categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
        html_documentation: Optional[StrictStr] = None,
        proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
        report_configs: Optional[PipelineReportConfig] = None,
        resources: Optional[PipelineResources] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a Nextflow pipeline within a project.


        :param project_id: (required)
        :type project_id: str
        :param code: The code of the pipeline (required)
        :type code: str
        :param description: The description of the pipeline (required)
        :type description: str
        :param main_nextflow_file: The main Nextflow file. (required)
        :type main_nextflow_file: bytearray
        :param parameters_xml_file: (required)
        :type parameters_xml_file: bytearray
        :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
        :type analysis_storage_id: str
        :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
        :type pipeline_language_version_id: str
        :param nextflow_config_file: The Nextflow config file.
        :type nextflow_config_file: bytearray
        :param other_nextflow_files:
        :type other_nextflow_files: List[bytearray]
        :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
        :type metadata_model_file: bytearray
        :param links:
        :type links: Links
        :param version_comment:
        :type version_comment: str
        :param categories:
        :type categories: List[Optional[str]]
        :param html_documentation:
        :type html_documentation: str
        :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
        :type proprietary: bool
        :param report_configs:
        :type report_configs: PipelineReportConfig
        :param resources:
        :type resources: PipelineResources
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_nextflow_pipeline_serialize(
            project_id=project_id,
            code=code,
            description=description,
            main_nextflow_file=main_nextflow_file,
            parameters_xml_file=parameters_xml_file,
            analysis_storage_id=analysis_storage_id,
            pipeline_language_version_id=pipeline_language_version_id,
            nextflow_config_file=nextflow_config_file,
            other_nextflow_files=other_nextflow_files,
            metadata_model_file=metadata_model_file,
            links=links,
            version_comment=version_comment,
            categories=categories,
            html_documentation=html_documentation,
            proprietary=proprietary,
            report_configs=report_configs,
            resources=resources,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectPipeline",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_nextflow_pipeline_serialize(
        self,
        project_id,
        code,
        description,
        main_nextflow_file,
        parameters_xml_file,
        analysis_storage_id,
        pipeline_language_version_id,
        nextflow_config_file,
        other_nextflow_files,
        metadata_model_file,
        links,
        version_comment,
        categories,
        html_documentation,
        proprietary,
        report_configs,
        resources,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'otherNextflowFiles': 'csv',
            'categories': 'csv',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if code is not None:
            _form_params.append(('code', code))
        if pipeline_language_version_id is not None:
            _form_params.append(('pipelineLanguageVersionId', pipeline_language_version_id))
        if description is not None:
            _form_params.append(('description', description))
        if main_nextflow_file is not None:
            _files['mainNextflowFile'] = main_nextflow_file
        if nextflow_config_file is not None:
            _files['nextflowConfigFile'] = nextflow_config_file
        if other_nextflow_files is not None:
            _files['otherNextflowFiles'] = other_nextflow_files
        if parameters_xml_file is not None:
            _files['parametersXmlFile'] = parameters_xml_file
        if metadata_model_file is not None:
            _files['metadataModelFile'] = metadata_model_file
        if links is not None:
            _form_params.append(('links', links))
        if version_comment is not None:
            _form_params.append(('versionComment', version_comment))
        if categories is not None:
            _form_params.append(('categories', categories))
        if html_documentation is not None:
            _form_params.append(('htmlDocumentation', html_documentation))
        if analysis_storage_id is not None:
            _form_params.append(('analysisStorageId', analysis_storage_id))
        if proprietary is not None:
            _form_params.append(('proprietary', proprietary))
        if report_configs is not None:
            _form_params.append(('reportConfigs', report_configs))
        if resources is not None:
            _form_params.append(('resources', resources))
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/pipelines:createNextflowPipeline',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_project_pipeline_file(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineFile:
        """Create a file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to create a file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "PipelineFile",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_project_pipeline_file_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineFile]:
        """Create a file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to create a file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "PipelineFile",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_project_pipeline_file_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to create a file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "PipelineFile",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_project_pipeline_file_serialize(
        self,
        project_id,
        pipeline_id,
        content,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if content is not None:
            _files['content'] = content
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/files',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_additional_project_pipeline_file(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete an additional file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete an additional input form file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to delete an additional file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_additional_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_additional_project_pipeline_file_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete an additional file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete an additional input form file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to delete an additional file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_additional_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_additional_project_pipeline_file_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete an additional file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete an additional input form file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to delete an additional file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_additional_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_additional_project_pipeline_file_serialize(
        self,
        project_id,
        pipeline_id,
        file_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        if file_id is not None:
            _path_params['fileId'] = file_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/additionalFiles/{fileId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_project_pipeline_file(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete a file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to delete a file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_project_pipeline_file_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete a file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to delete a file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_project_pipeline_file_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete a file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to delete a file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_project_pipeline_file_serialize(
        self,
        project_id,
        pipeline_id,
        file_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        if file_id is not None:
            _path_params['fileId'] = file_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/files/{fileId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def download_additional_file_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the additional file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> bytearray:
        """Download the contents of an additional input form file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the additional file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the additional file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_additional_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def download_additional_file_content_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the additional file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[bytearray]:
        """Download the contents of an additional input form file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the additional file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the additional file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_additional_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def download_additional_file_content_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the additional file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Download the contents of an additional input form file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the additional file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the additional file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_additional_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _download_additional_file_content_serialize(
        self,
        project_id,
        pipeline_id,
        file_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        if file_id is not None:
            _path_params['fileId'] = file_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/octet-stream'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/additionalFiles/{fileId}/content',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def download_input_form_file_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the input form file for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> bytearray:
        """Download the contents of the input form file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the input form file for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_input_form_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def download_input_form_file_content_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the input form file for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[bytearray]:
        """Download the contents of the input form file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the input form file for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_input_form_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def download_input_form_file_content_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the input form file for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Download the contents of the input form file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the input form file for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_input_form_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _download_input_form_file_content_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/octet-stream'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/inputFormFile',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def download_on_render_file_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onRender file for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> bytearray:
        """Download the contents of the onRender file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the onRender file for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_on_render_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def download_on_render_file_content_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onRender file for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[bytearray]:
        """Download the contents of the onRender file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the onRender file for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_on_render_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def download_on_render_file_content_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onRender file for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Download the contents of the onRender file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the onRender file for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_on_render_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _download_on_render_file_content_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/octet-stream'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/onRenderFile',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def download_on_submit_file_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onSubmit file for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> bytearray:
        """Download the contents of the onSubmit file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the onSubmit file for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_on_submit_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def download_on_submit_file_content_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onSubmit file for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[bytearray]:
        """Download the contents of the onSubmit file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the onSubmit file for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_on_submit_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def download_on_submit_file_content_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onSubmit file for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Download the contents of the onSubmit file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve the onSubmit file for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_on_submit_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _download_on_submit_file_content_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/octet-stream'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/onSubmitFile',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def download_project_pipeline_file_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> bytearray:
        """Download the contents of a pipeline file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_project_pipeline_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def download_project_pipeline_file_content_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[bytearray]:
        """Download the contents of a pipeline file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_project_pipeline_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def download_project_pipeline_file_content_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Download the contents of a pipeline file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._download_project_pipeline_file_content_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "bytearray",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _download_project_pipeline_file_content_serialize(
        self,
        project_id,
        pipeline_id,
        file_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        if file_id is not None:
            _path_params['fileId'] = file_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/octet-stream'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/files/{fileId}/content',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_pipeline(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPipelineV4:
        """Retrieve a project pipeline.

        Retrieves a project pipeline. This can be a pipeline from a linked bundle or an entitled, unlinked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_pipeline_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPipelineV4]:
        """Retrieve a project pipeline.

        Retrieves a project pipeline. This can be a pipeline from a linked bundle or an entitled, unlinked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_pipeline_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project pipeline.

        Retrieves a project pipeline. This can be a pipeline from a linked bundle or an entitled, unlinked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_pipeline_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_pipeline_additional_files(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineFileList:
        """Retrieve additional input form files for a project pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_additional_files_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineFileList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_pipeline_additional_files_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineFileList]:
        """Retrieve additional input form files for a project pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_additional_files_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineFileList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_pipeline_additional_files_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve additional input form files for a project pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_additional_files_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineFileList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_pipeline_additional_files_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/additionalFiles',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_pipeline_configuration_parameters(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineConfigurationParameterList:
        """Retrieve configuration parameters for a project pipeline.

        The pipeline can originate from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_configuration_parameters_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineConfigurationParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_pipeline_configuration_parameters_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineConfigurationParameterList]:
        """Retrieve configuration parameters for a project pipeline.

        The pipeline can originate from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_configuration_parameters_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineConfigurationParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_pipeline_configuration_parameters_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve configuration parameters for a project pipeline.

        The pipeline can originate from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_configuration_parameters_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineConfigurationParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_pipeline_configuration_parameters_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/configurationParameters',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_pipeline_files(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineFileList:
        """Retrieve files for a project pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_files_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineFileList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_pipeline_files_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineFileList]:
        """Retrieve files for a project pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_files_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineFileList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_pipeline_files_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve files for a project pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_files_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineFileList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_pipeline_files_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/files',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_pipeline_html_documentation(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineHtmlDocumentation:
        """Retrieve HTML documentation for a project pipeline.

        Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_html_documentation_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineHtmlDocumentation",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_pipeline_html_documentation_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineHtmlDocumentation]:
        """Retrieve HTML documentation for a project pipeline.

        Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_html_documentation_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineHtmlDocumentation",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_pipeline_html_documentation_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve HTML documentation for a project pipeline.

        Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_html_documentation_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineHtmlDocumentation",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_pipeline_html_documentation_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/documentation/HTML',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_pipeline_input_parameters(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> InputParameterList:
        """Retrieve input parameters for a project pipeline.

        The pipeline can originate from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_input_parameters_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InputParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_pipeline_input_parameters_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[InputParameterList]:
        """Retrieve input parameters for a project pipeline.

        The pipeline can originate from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_input_parameters_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InputParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_pipeline_input_parameters_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve input parameters for a project pipeline.

        The pipeline can originate from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_input_parameters_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "InputParameterList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_pipeline_input_parameters_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputParameters',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_pipeline_reference_sets(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ReferenceSetList:
        """Retrieve the reference sets of a project pipeline.

        Retrieve the reference sets of a project pipeline. This can be a pipeline from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_reference_sets_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ReferenceSetList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_pipeline_reference_sets_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ReferenceSetList]:
        """Retrieve the reference sets of a project pipeline.

        Retrieve the reference sets of a project pipeline. This can be a pipeline from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_reference_sets_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ReferenceSetList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_pipeline_reference_sets_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the reference sets of a project pipeline.

        Retrieve the reference sets of a project pipeline. This can be a pipeline from a linked bundle.

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipeline_reference_sets_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ReferenceSetList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_pipeline_reference_sets_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/referenceSets',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_pipelines(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project to retrieve pipelines for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectPipelineList:
        """Retrieve a list of project pipelines.

        Lists all pipelines that are available to the project.

        :param project_id: The ID of the project to retrieve pipelines for (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipelines_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPipelineList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_pipelines_with_http_info(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project to retrieve pipelines for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectPipelineList]:
        """Retrieve a list of project pipelines.

        Lists all pipelines that are available to the project.

        :param project_id: The ID of the project to retrieve pipelines for (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipelines_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPipelineList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_pipelines_without_preload_content(
        self,
        project_id: Annotated[StrictStr, Field(description="The ID of the project to retrieve pipelines for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of project pipelines.

        Lists all pipelines that are available to the project.

        :param project_id: The ID of the project to retrieve pipelines for (required)
        :type project_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_pipelines_serialize(
            project_id=project_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectPipelineList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_pipelines_serialize(
        self,
        project_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/pipelines',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def link_pipeline_to_project(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Link a pipeline to a project.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_pipeline_to_project_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def link_pipeline_to_project_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Link a pipeline to a project.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_pipeline_to_project_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def link_pipeline_to_project_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Link a pipeline to a project.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_pipeline_to_project_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _link_pipeline_to_project_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def release_project_pipeline(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Release a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._release_project_pipeline_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def release_project_pipeline_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Release a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._release_project_pipeline_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def release_project_pipeline_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Release a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._release_project_pipeline_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _release_project_pipeline_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}:release',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unlink_pipeline_from_project(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Unlink a pipeline from a project.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_pipeline_from_project_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unlink_pipeline_from_project_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Unlink a pipeline from a project.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_pipeline_from_project_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unlink_pipeline_from_project_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Unlink a pipeline from a project.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the pipeline (required)
        :type pipeline_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_pipeline_from_project_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unlink_pipeline_from_project_serialize(
        self,
        project_id,
        pipeline_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='DELETE',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_additional_file(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the additional file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Update the contents of an additional input form file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update the additional file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the additional file (required)
        :type file_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_additional_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_additional_file_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the additional file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Update the contents of an additional input form file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update the additional file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the additional file (required)
        :type file_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_additional_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_additional_file_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the additional file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update the contents of an additional input form file.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update the additional file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the additional file (required)
        :type file_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_additional_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_additional_file_serialize(
        self,
        project_id,
        pipeline_id,
        file_id,
        content,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        if file_id is not None:
            _path_params['fileId'] = file_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if content is not None:
            _files['content'] = content
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/additionalFiles/{fileId}/content',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_general_attributes_project_pipeline(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update")],
        pipeline_update: PipelineUpdate,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> PipelineV4:
        """Update the general attributes of a project pipeline.

        Attributes which can be updated: - code - description - languageVersion - proprietary - resources 

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update (required)
        :type pipeline_id: str
        :param pipeline_update: (required)
        :type pipeline_update: PipelineUpdate
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_general_attributes_project_pipeline_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            pipeline_update=pipeline_update,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_general_attributes_project_pipeline_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update")],
        pipeline_update: PipelineUpdate,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[PipelineV4]:
        """Update the general attributes of a project pipeline.

        Attributes which can be updated: - code - description - languageVersion - proprietary - resources 

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update (required)
        :type pipeline_id: str
        :param pipeline_update: (required)
        :type pipeline_update: PipelineUpdate
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_general_attributes_project_pipeline_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            pipeline_update=pipeline_update,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_general_attributes_project_pipeline_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update")],
        pipeline_update: PipelineUpdate,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update the general attributes of a project pipeline.

        Attributes which can be updated: - code - description - languageVersion - proprietary - resources 

        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update (required)
        :type pipeline_id: str
        :param pipeline_update: (required)
        :type pipeline_update: PipelineUpdate
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_general_attributes_project_pipeline_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            pipeline_update=pipeline_update,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "PipelineV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_general_attributes_project_pipeline_serialize(
        self,
        project_id,
        pipeline_id,
        pipeline_update,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if pipeline_update is not None:
            _body_params = pipeline_update


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v4+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v4+json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/generalAttributes',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_input_form_file(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Update the contents of the input form file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update a file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_input_form_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_input_form_file_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Update the contents of the input form file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update a file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_input_form_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_input_form_file_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update the contents of the input form file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update a file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_input_form_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_input_form_file_serialize(
        self,
        project_id,
        pipeline_id,
        content,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if content is not None:
            _files['content'] = content
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/inputFormFile',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_on_render_file(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onRender file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Update the contents of the onRender file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update the onRender file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_on_render_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_on_render_file_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onRender file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Update the contents of the onRender file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update the onRender file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_on_render_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_on_render_file_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onRender file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update the contents of the onRender file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update the onRender file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_on_render_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_on_render_file_serialize(
        self,
        project_id,
        pipeline_id,
        content,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if content is not None:
            _files['content'] = content
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/onRenderFile',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_on_submit_file(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onSubmit file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Update the contents of the onSubmit file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update the onSubmit file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_on_submit_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_on_submit_file_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onSubmit file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Update the contents of the onSubmit file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update the onSubmit file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_on_submit_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_on_submit_file_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onSubmit file for")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update the contents of the onSubmit file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update the onSubmit file for (required)
        :type pipeline_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_on_submit_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_on_submit_file_serialize(
        self,
        project_id,
        pipeline_id,
        content,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if content is not None:
            _files['content'] = content
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/inputForm/onSubmitFile',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_project_pipeline_file(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Update the contents of a file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update a file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_project_pipeline_file_with_http_info(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Update the contents of a file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update a file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_project_pipeline_file_without_preload_content(
        self,
        project_id: StrictStr,
        pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
        file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
        content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update the contents of a file for a pipeline.


        :param project_id: (required)
        :type project_id: str
        :param pipeline_id: The ID of the project pipeline to update a file for (required)
        :type pipeline_id: str
        :param file_id: The ID of the pipeline file (required)
        :type file_id: str
        :param content: (required)
        :type content: bytearray
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_pipeline_file_serialize(
            project_id=project_id,
            pipeline_id=pipeline_id,
            file_id=file_id,
            content=content,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_project_pipeline_file_serialize(
        self,
        project_id,
        pipeline_id,
        file_id,
        content,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if pipeline_id is not None:
            _path_params['pipelineId'] = pipeline_id
        if file_id is not None:
            _path_params['fileId'] = file_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        if content is not None:
            _files['content'] = content
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'multipart/form-data'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/pipelines/{pipelineId}/files/{fileId}/content',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_additional_project_pipeline_file(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to create a file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> PipelineFile

Expand source code

@validate_call
def create_additional_project_pipeline_file(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineFile:
    """Create an additional input form file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to create a file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_additional_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "PipelineFile",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create an additional input form file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to create a file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_additional_project_pipeline_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to create a file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> ApiResponse[PipelineFile]

Expand source code

@validate_call
def create_additional_project_pipeline_file_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineFile]:
    """Create an additional input form file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to create a file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_additional_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "PipelineFile",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create an additional input form file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to create a file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_additional_project_pipeline_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to create a file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_additional_project_pipeline_file_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create an additional input form file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to create a file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_additional_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "PipelineFile",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create an additional input form file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to create a file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_json_pipeline(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
workflow_cwl_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The CWL workflow file.')],
input_form_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The JSON based input form.')],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
tool_cwl_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
on_render_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will render the current state of the input form.')] = None,
on_submit_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will submit the current state of the input form.')] = None,
other_input_form_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> ProjectPipelineV4

Expand source code

@validate_call
def create_cwl_json_pipeline(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
    workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
    input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
    on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
    other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPipelineV4:
    """Create a JSON based CWL pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the CWL pipeline (required)
    :type code: str
    :param description: The description of the CWL pipeline (required)
    :type description: str
    :param workflow_cwl_file: The CWL workflow file. (required)
    :type workflow_cwl_file: bytearray
    :param input_form_file: The JSON based input form. (required)
    :type input_form_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param tool_cwl_files:
    :type tool_cwl_files: List[bytearray]
    :param on_render_file: A file that will render the current state of the input form.
    :type on_render_file: bytearray
    :param on_submit_file: A file that will submit the current state of the input form.
    :type on_submit_file: bytearray
    :param other_input_form_files:
    :type other_input_form_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_json_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        workflow_cwl_file=workflow_cwl_file,
        input_form_file=input_form_file,
        analysis_storage_id=analysis_storage_id,
        tool_cwl_files=tool_cwl_files,
        on_render_file=on_render_file,
        on_submit_file=on_submit_file,
        other_input_form_files=other_input_form_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a JSON based CWL pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the CWL pipeline (required) :type code: str :param description: The description of the CWL pipeline (required) :type description: str :param workflow_cwl_file: The CWL workflow file. (required) :type workflow_cwl_file: bytearray :param input_form_file: The JSON based input form. (required) :type input_form_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param tool_cwl_files: :type tool_cwl_files: List[bytearray] :param on_render_file: A file that will render the current state of the input form. :type on_render_file: bytearray :param on_submit_file: A file that will submit the current state of the input form. :type on_submit_file: bytearray :param other_input_form_files: :type other_input_form_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_json_pipeline_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
workflow_cwl_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The CWL workflow file.')],
input_form_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The JSON based input form.')],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
tool_cwl_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
on_render_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will render the current state of the input form.')] = None,
on_submit_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will submit the current state of the input form.')] = None,
other_input_form_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> ApiResponse[ProjectPipelineV4]

Expand source code

@validate_call
def create_cwl_json_pipeline_with_http_info(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
    workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
    input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
    on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
    other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPipelineV4]:
    """Create a JSON based CWL pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the CWL pipeline (required)
    :type code: str
    :param description: The description of the CWL pipeline (required)
    :type description: str
    :param workflow_cwl_file: The CWL workflow file. (required)
    :type workflow_cwl_file: bytearray
    :param input_form_file: The JSON based input form. (required)
    :type input_form_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param tool_cwl_files:
    :type tool_cwl_files: List[bytearray]
    :param on_render_file: A file that will render the current state of the input form.
    :type on_render_file: bytearray
    :param on_submit_file: A file that will submit the current state of the input form.
    :type on_submit_file: bytearray
    :param other_input_form_files:
    :type other_input_form_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_json_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        workflow_cwl_file=workflow_cwl_file,
        input_form_file=input_form_file,
        analysis_storage_id=analysis_storage_id,
        tool_cwl_files=tool_cwl_files,
        on_render_file=on_render_file,
        on_submit_file=on_submit_file,
        other_input_form_files=other_input_form_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a JSON based CWL pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the CWL pipeline (required) :type code: str :param description: The description of the CWL pipeline (required) :type description: str :param workflow_cwl_file: The CWL workflow file. (required) :type workflow_cwl_file: bytearray :param input_form_file: The JSON based input form. (required) :type input_form_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param tool_cwl_files: :type tool_cwl_files: List[bytearray] :param on_render_file: A file that will render the current state of the input form. :type on_render_file: bytearray :param on_submit_file: A file that will submit the current state of the input form. :type on_submit_file: bytearray :param other_input_form_files: :type other_input_form_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_json_pipeline_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
workflow_cwl_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The CWL workflow file.')],
input_form_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The JSON based input form.')],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
tool_cwl_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
on_render_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will render the current state of the input form.')] = None,
on_submit_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will submit the current state of the input form.')] = None,
other_input_form_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_cwl_json_pipeline_without_preload_content(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
    workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
    input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
    on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
    other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a JSON based CWL pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the CWL pipeline (required)
    :type code: str
    :param description: The description of the CWL pipeline (required)
    :type description: str
    :param workflow_cwl_file: The CWL workflow file. (required)
    :type workflow_cwl_file: bytearray
    :param input_form_file: The JSON based input form. (required)
    :type input_form_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param tool_cwl_files:
    :type tool_cwl_files: List[bytearray]
    :param on_render_file: A file that will render the current state of the input form.
    :type on_render_file: bytearray
    :param on_submit_file: A file that will submit the current state of the input form.
    :type on_submit_file: bytearray
    :param other_input_form_files:
    :type other_input_form_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_json_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        workflow_cwl_file=workflow_cwl_file,
        input_form_file=input_form_file,
        analysis_storage_id=analysis_storage_id,
        tool_cwl_files=tool_cwl_files,
        on_render_file=on_render_file,
        on_submit_file=on_submit_file,
        other_input_form_files=other_input_form_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a JSON based CWL pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the CWL pipeline (required) :type code: str :param description: The description of the CWL pipeline (required) :type description: str :param workflow_cwl_file: The CWL workflow file. (required) :type workflow_cwl_file: bytearray :param input_form_file: The JSON based input form. (required) :type input_form_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param tool_cwl_files: :type tool_cwl_files: List[bytearray] :param on_render_file: A file that will render the current state of the input form. :type on_render_file: bytearray :param on_submit_file: A file that will submit the current state of the input form. :type on_submit_file: bytearray :param other_input_form_files: :type other_input_form_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_pipeline(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
workflow_cwl_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The CWL workflow file.')],
parameters_xml_file: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
tool_cwl_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> ProjectPipeline

Expand source code

@validate_call
def create_cwl_pipeline(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
    workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
    parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPipeline:
    """Create a CWL pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the CWL pipeline (required)
    :type code: str
    :param description: The description of the CWL pipeline (required)
    :type description: str
    :param workflow_cwl_file: The CWL workflow file. (required)
    :type workflow_cwl_file: bytearray
    :param parameters_xml_file: (required)
    :type parameters_xml_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param tool_cwl_files:
    :type tool_cwl_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        workflow_cwl_file=workflow_cwl_file,
        parameters_xml_file=parameters_xml_file,
        analysis_storage_id=analysis_storage_id,
        tool_cwl_files=tool_cwl_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPipeline",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a CWL pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the CWL pipeline (required) :type code: str :param description: The description of the CWL pipeline (required) :type description: str :param workflow_cwl_file: The CWL workflow file. (required) :type workflow_cwl_file: bytearray :param parameters_xml_file: (required) :type parameters_xml_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param tool_cwl_files: :type tool_cwl_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_pipeline_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
workflow_cwl_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The CWL workflow file.')],
parameters_xml_file: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
tool_cwl_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> ApiResponse[ProjectPipeline]

Expand source code

@validate_call
def create_cwl_pipeline_with_http_info(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
    workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
    parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPipeline]:
    """Create a CWL pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the CWL pipeline (required)
    :type code: str
    :param description: The description of the CWL pipeline (required)
    :type description: str
    :param workflow_cwl_file: The CWL workflow file. (required)
    :type workflow_cwl_file: bytearray
    :param parameters_xml_file: (required)
    :type parameters_xml_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param tool_cwl_files:
    :type tool_cwl_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        workflow_cwl_file=workflow_cwl_file,
        parameters_xml_file=parameters_xml_file,
        analysis_storage_id=analysis_storage_id,
        tool_cwl_files=tool_cwl_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPipeline",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a CWL pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the CWL pipeline (required) :type code: str :param description: The description of the CWL pipeline (required) :type description: str :param workflow_cwl_file: The CWL workflow file. (required) :type workflow_cwl_file: bytearray :param parameters_xml_file: (required) :type parameters_xml_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param tool_cwl_files: :type tool_cwl_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_cwl_pipeline_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the CWL pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
workflow_cwl_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The CWL workflow file.')],
parameters_xml_file: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
tool_cwl_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_cwl_pipeline_without_preload_content(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the CWL pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the CWL pipeline")],
    workflow_cwl_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The CWL workflow file.")],
    parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    tool_cwl_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a CWL pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the CWL pipeline (required)
    :type code: str
    :param description: The description of the CWL pipeline (required)
    :type description: str
    :param workflow_cwl_file: The CWL workflow file. (required)
    :type workflow_cwl_file: bytearray
    :param parameters_xml_file: (required)
    :type parameters_xml_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param tool_cwl_files:
    :type tool_cwl_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_cwl_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        workflow_cwl_file=workflow_cwl_file,
        parameters_xml_file=parameters_xml_file,
        analysis_storage_id=analysis_storage_id,
        tool_cwl_files=tool_cwl_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPipeline",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a CWL pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the CWL pipeline (required) :type code: str :param description: The description of the CWL pipeline (required) :type description: str :param workflow_cwl_file: The CWL workflow file. (required) :type workflow_cwl_file: bytearray :param parameters_xml_file: (required) :type parameters_xml_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param tool_cwl_files: :type tool_cwl_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_json_pipeline(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
main_nextflow_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The main Nextflow file.')],
input_form_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The JSON based input form.')],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
pipeline_language_version_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The id of the Nextflow version to use for the pipeline.')] = None,
nextflow_config_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The Nextflow config file.')] = None,
other_nextflow_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
on_render_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will render the current state of the input form.')] = None,
on_submit_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will submit the current state of the input form.')] = None,
other_input_form_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> PipelineV4

Expand source code

@validate_call
def create_nextflow_json_pipeline(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
    main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
    input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
    nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
    other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
    on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
    other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineV4:
    """Create a JSON based Nextflow pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the pipeline (required)
    :type code: str
    :param description: The description of the pipeline (required)
    :type description: str
    :param main_nextflow_file: The main Nextflow file. (required)
    :type main_nextflow_file: bytearray
    :param input_form_file: The JSON based input form. (required)
    :type input_form_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
    :type pipeline_language_version_id: str
    :param nextflow_config_file: The Nextflow config file.
    :type nextflow_config_file: bytearray
    :param other_nextflow_files:
    :type other_nextflow_files: List[bytearray]
    :param on_render_file: A file that will render the current state of the input form.
    :type on_render_file: bytearray
    :param on_submit_file: A file that will submit the current state of the input form.
    :type on_submit_file: bytearray
    :param other_input_form_files:
    :type other_input_form_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_json_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        main_nextflow_file=main_nextflow_file,
        input_form_file=input_form_file,
        analysis_storage_id=analysis_storage_id,
        pipeline_language_version_id=pipeline_language_version_id,
        nextflow_config_file=nextflow_config_file,
        other_nextflow_files=other_nextflow_files,
        on_render_file=on_render_file,
        on_submit_file=on_submit_file,
        other_input_form_files=other_input_form_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "PipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a JSON based Nextflow pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the pipeline (required) :type code: str :param description: The description of the pipeline (required) :type description: str :param main_nextflow_file: The main Nextflow file. (required) :type main_nextflow_file: bytearray :param input_form_file: The JSON based input form. (required) :type input_form_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline. :type pipeline_language_version_id: str :param nextflow_config_file: The Nextflow config file. :type nextflow_config_file: bytearray :param other_nextflow_files: :type other_nextflow_files: List[bytearray] :param on_render_file: A file that will render the current state of the input form. :type on_render_file: bytearray :param on_submit_file: A file that will submit the current state of the input form. :type on_submit_file: bytearray :param other_input_form_files: :type other_input_form_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_json_pipeline_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
main_nextflow_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The main Nextflow file.')],
input_form_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The JSON based input form.')],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
pipeline_language_version_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The id of the Nextflow version to use for the pipeline.')] = None,
nextflow_config_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The Nextflow config file.')] = None,
other_nextflow_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
on_render_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will render the current state of the input form.')] = None,
on_submit_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will submit the current state of the input form.')] = None,
other_input_form_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> ApiResponse[PipelineV4]

Expand source code

@validate_call
def create_nextflow_json_pipeline_with_http_info(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
    main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
    input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
    nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
    other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
    on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
    other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineV4]:
    """Create a JSON based Nextflow pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the pipeline (required)
    :type code: str
    :param description: The description of the pipeline (required)
    :type description: str
    :param main_nextflow_file: The main Nextflow file. (required)
    :type main_nextflow_file: bytearray
    :param input_form_file: The JSON based input form. (required)
    :type input_form_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
    :type pipeline_language_version_id: str
    :param nextflow_config_file: The Nextflow config file.
    :type nextflow_config_file: bytearray
    :param other_nextflow_files:
    :type other_nextflow_files: List[bytearray]
    :param on_render_file: A file that will render the current state of the input form.
    :type on_render_file: bytearray
    :param on_submit_file: A file that will submit the current state of the input form.
    :type on_submit_file: bytearray
    :param other_input_form_files:
    :type other_input_form_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_json_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        main_nextflow_file=main_nextflow_file,
        input_form_file=input_form_file,
        analysis_storage_id=analysis_storage_id,
        pipeline_language_version_id=pipeline_language_version_id,
        nextflow_config_file=nextflow_config_file,
        other_nextflow_files=other_nextflow_files,
        on_render_file=on_render_file,
        on_submit_file=on_submit_file,
        other_input_form_files=other_input_form_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "PipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a JSON based Nextflow pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the pipeline (required) :type code: str :param description: The description of the pipeline (required) :type description: str :param main_nextflow_file: The main Nextflow file. (required) :type main_nextflow_file: bytearray :param input_form_file: The JSON based input form. (required) :type input_form_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline. :type pipeline_language_version_id: str :param nextflow_config_file: The Nextflow config file. :type nextflow_config_file: bytearray :param other_nextflow_files: :type other_nextflow_files: List[bytearray] :param on_render_file: A file that will render the current state of the input form. :type on_render_file: bytearray :param on_submit_file: A file that will submit the current state of the input form. :type on_submit_file: bytearray :param other_input_form_files: :type other_input_form_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_json_pipeline_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
main_nextflow_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The main Nextflow file.')],
input_form_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The JSON based input form.')],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
pipeline_language_version_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The id of the Nextflow version to use for the pipeline.')] = None,
nextflow_config_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The Nextflow config file.')] = None,
other_nextflow_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
on_render_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will render the current state of the input form.')] = None,
on_submit_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='A file that will submit the current state of the input form.')] = None,
other_input_form_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_nextflow_json_pipeline_without_preload_content(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
    main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
    input_form_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The JSON based input form.")],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
    nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
    other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    on_render_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will render the current state of the input form.")] = None,
    on_submit_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="A file that will submit the current state of the input form.")] = None,
    other_input_form_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a JSON based Nextflow pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the pipeline (required)
    :type code: str
    :param description: The description of the pipeline (required)
    :type description: str
    :param main_nextflow_file: The main Nextflow file. (required)
    :type main_nextflow_file: bytearray
    :param input_form_file: The JSON based input form. (required)
    :type input_form_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
    :type pipeline_language_version_id: str
    :param nextflow_config_file: The Nextflow config file.
    :type nextflow_config_file: bytearray
    :param other_nextflow_files:
    :type other_nextflow_files: List[bytearray]
    :param on_render_file: A file that will render the current state of the input form.
    :type on_render_file: bytearray
    :param on_submit_file: A file that will submit the current state of the input form.
    :type on_submit_file: bytearray
    :param other_input_form_files:
    :type other_input_form_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_json_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        main_nextflow_file=main_nextflow_file,
        input_form_file=input_form_file,
        analysis_storage_id=analysis_storage_id,
        pipeline_language_version_id=pipeline_language_version_id,
        nextflow_config_file=nextflow_config_file,
        other_nextflow_files=other_nextflow_files,
        on_render_file=on_render_file,
        on_submit_file=on_submit_file,
        other_input_form_files=other_input_form_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "PipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a JSON based Nextflow pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the pipeline (required) :type code: str :param description: The description of the pipeline (required) :type description: str :param main_nextflow_file: The main Nextflow file. (required) :type main_nextflow_file: bytearray :param input_form_file: The JSON based input form. (required) :type input_form_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline. :type pipeline_language_version_id: str :param nextflow_config_file: The Nextflow config file. :type nextflow_config_file: bytearray :param other_nextflow_files: :type other_nextflow_files: List[bytearray] :param on_render_file: A file that will render the current state of the input form. :type on_render_file: bytearray :param on_submit_file: A file that will submit the current state of the input form. :type on_submit_file: bytearray :param other_input_form_files: :type other_input_form_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_pipeline(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
main_nextflow_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The main Nextflow file.')],
parameters_xml_file: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
pipeline_language_version_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The id of the Nextflow version to use for the pipeline.')] = None,
nextflow_config_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The Nextflow config file.')] = None,
other_nextflow_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> ProjectPipeline

Expand source code

@validate_call
def create_nextflow_pipeline(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
    main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
    parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
    nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
    other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPipeline:
    """Create a Nextflow pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the pipeline (required)
    :type code: str
    :param description: The description of the pipeline (required)
    :type description: str
    :param main_nextflow_file: The main Nextflow file. (required)
    :type main_nextflow_file: bytearray
    :param parameters_xml_file: (required)
    :type parameters_xml_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
    :type pipeline_language_version_id: str
    :param nextflow_config_file: The Nextflow config file.
    :type nextflow_config_file: bytearray
    :param other_nextflow_files:
    :type other_nextflow_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        main_nextflow_file=main_nextflow_file,
        parameters_xml_file=parameters_xml_file,
        analysis_storage_id=analysis_storage_id,
        pipeline_language_version_id=pipeline_language_version_id,
        nextflow_config_file=nextflow_config_file,
        other_nextflow_files=other_nextflow_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPipeline",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a Nextflow pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the pipeline (required) :type code: str :param description: The description of the pipeline (required) :type description: str :param main_nextflow_file: The main Nextflow file. (required) :type main_nextflow_file: bytearray :param parameters_xml_file: (required) :type parameters_xml_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline. :type pipeline_language_version_id: str :param nextflow_config_file: The Nextflow config file. :type nextflow_config_file: bytearray :param other_nextflow_files: :type other_nextflow_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_pipeline_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
main_nextflow_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The main Nextflow file.')],
parameters_xml_file: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
pipeline_language_version_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The id of the Nextflow version to use for the pipeline.')] = None,
nextflow_config_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The Nextflow config file.')] = None,
other_nextflow_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> ApiResponse[ProjectPipeline]

Expand source code

@validate_call
def create_nextflow_pipeline_with_http_info(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
    main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
    parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
    nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
    other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPipeline]:
    """Create a Nextflow pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the pipeline (required)
    :type code: str
    :param description: The description of the pipeline (required)
    :type description: str
    :param main_nextflow_file: The main Nextflow file. (required)
    :type main_nextflow_file: bytearray
    :param parameters_xml_file: (required)
    :type parameters_xml_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
    :type pipeline_language_version_id: str
    :param nextflow_config_file: The Nextflow config file.
    :type nextflow_config_file: bytearray
    :param other_nextflow_files:
    :type other_nextflow_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        main_nextflow_file=main_nextflow_file,
        parameters_xml_file=parameters_xml_file,
        analysis_storage_id=analysis_storage_id,
        pipeline_language_version_id=pipeline_language_version_id,
        nextflow_config_file=nextflow_config_file,
        other_nextflow_files=other_nextflow_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPipeline",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a Nextflow pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the pipeline (required) :type code: str :param description: The description of the pipeline (required) :type description: str :param main_nextflow_file: The main Nextflow file. (required) :type main_nextflow_file: bytearray :param parameters_xml_file: (required) :type parameters_xml_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline. :type pipeline_language_version_id: str :param nextflow_config_file: The Nextflow config file. :type nextflow_config_file: bytearray :param other_nextflow_files: :type other_nextflow_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_nextflow_pipeline_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
code: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The code of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=255)])],
description: Annotated[str, FieldInfo(annotation=NoneType, required=True, description='The description of the pipeline', metadata=[Strict(strict=True), MinLen(min_length=1), MaxLen(max_length=4000)])],
main_nextflow_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]], FieldInfo(annotation=NoneType, required=True, description='The main Nextflow file.')],
parameters_xml_file: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]],
analysis_storage_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The id of the storage to use for the pipeline.')],
pipeline_language_version_id: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The id of the Nextflow version to use for the pipeline.')] = None,
nextflow_config_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The Nextflow config file.')] = None,
other_nextflow_files: List[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]] | None = None,
metadata_model_file: Annotated[Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The metadata model json file(contents can be retrieved from the controlplane).')] = None,
links: Links | None = None,
version_comment: Annotated[str, Strict(strict=True)] | None = None,
categories: Annotated[List[Annotated[str, Strict(strict=True)] | None], FieldInfo(annotation=NoneType, required=True, metadata=[MinLen(min_length=1), MaxLen(max_length=4000)])] | None = None,
html_documentation: Annotated[str, Strict(strict=True)] | None = None,
proprietary: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='A boolean which indicates if the code of this pipeline is proprietary')] = None,
report_configs: PipelineReportConfig | None = None,
resources: PipelineResources | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_nextflow_pipeline_without_preload_content(
    self,
    project_id: StrictStr,
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255, description="The code of the pipeline")],
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000, description="The description of the pipeline")],
    main_nextflow_file: Annotated[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]], Field(description="The main Nextflow file.")],
    parameters_xml_file: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    analysis_storage_id: Annotated[StrictStr, Field(description="The id of the storage to use for the pipeline.")],
    pipeline_language_version_id: Annotated[Optional[StrictStr], Field(description="The id of the Nextflow version to use for the pipeline.")] = None,
    nextflow_config_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The Nextflow config file.")] = None,
    other_nextflow_files: Optional[List[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]]] = None,
    metadata_model_file: Annotated[Optional[Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]]], Field(description="The metadata model json file(contents can be retrieved from the controlplane).")] = None,
    links: Optional[Links] = None,
    version_comment: Optional[StrictStr] = None,
    categories: Optional[Annotated[List[Optional[StrictStr]], Field(min_length=1, max_length=4000)]] = None,
    html_documentation: Optional[StrictStr] = None,
    proprietary: Annotated[Optional[StrictBool], Field(description="A boolean which indicates if the code of this pipeline is proprietary")] = None,
    report_configs: Optional[PipelineReportConfig] = None,
    resources: Optional[PipelineResources] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a Nextflow pipeline within a project.


    :param project_id: (required)
    :type project_id: str
    :param code: The code of the pipeline (required)
    :type code: str
    :param description: The description of the pipeline (required)
    :type description: str
    :param main_nextflow_file: The main Nextflow file. (required)
    :type main_nextflow_file: bytearray
    :param parameters_xml_file: (required)
    :type parameters_xml_file: bytearray
    :param analysis_storage_id: The id of the storage to use for the pipeline. (required)
    :type analysis_storage_id: str
    :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline.
    :type pipeline_language_version_id: str
    :param nextflow_config_file: The Nextflow config file.
    :type nextflow_config_file: bytearray
    :param other_nextflow_files:
    :type other_nextflow_files: List[bytearray]
    :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane).
    :type metadata_model_file: bytearray
    :param links:
    :type links: Links
    :param version_comment:
    :type version_comment: str
    :param categories:
    :type categories: List[Optional[str]]
    :param html_documentation:
    :type html_documentation: str
    :param proprietary: A boolean which indicates if the code of this pipeline is proprietary
    :type proprietary: bool
    :param report_configs:
    :type report_configs: PipelineReportConfig
    :param resources:
    :type resources: PipelineResources
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_nextflow_pipeline_serialize(
        project_id=project_id,
        code=code,
        description=description,
        main_nextflow_file=main_nextflow_file,
        parameters_xml_file=parameters_xml_file,
        analysis_storage_id=analysis_storage_id,
        pipeline_language_version_id=pipeline_language_version_id,
        nextflow_config_file=nextflow_config_file,
        other_nextflow_files=other_nextflow_files,
        metadata_model_file=metadata_model_file,
        links=links,
        version_comment=version_comment,
        categories=categories,
        html_documentation=html_documentation,
        proprietary=proprietary,
        report_configs=report_configs,
        resources=resources,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectPipeline",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a Nextflow pipeline within a project.

:param project_id: (required) :type project_id: str :param code: The code of the pipeline (required) :type code: str :param description: The description of the pipeline (required) :type description: str :param main_nextflow_file: The main Nextflow file. (required) :type main_nextflow_file: bytearray :param parameters_xml_file: (required) :type parameters_xml_file: bytearray :param analysis_storage_id: The id of the storage to use for the pipeline. (required) :type analysis_storage_id: str :param pipeline_language_version_id: The id of the Nextflow version to use for the pipeline. :type pipeline_language_version_id: str :param nextflow_config_file: The Nextflow config file. :type nextflow_config_file: bytearray :param other_nextflow_files: :type other_nextflow_files: List[bytearray] :param metadata_model_file: The metadata model json file(contents can be retrieved from the controlplane). :type metadata_model_file: bytearray :param links: :type links: Links :param version_comment: :type version_comment: str :param categories: :type categories: List[Optional[str]] :param html_documentation: :type html_documentation: str :param proprietary: A boolean which indicates if the code of this pipeline is proprietary :type proprietary: bool :param report_configs: :type report_configs: PipelineReportConfig :param resources: :type resources: PipelineResources :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_pipeline_file(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to create a file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> PipelineFile

Expand source code

@validate_call
def create_project_pipeline_file(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineFile:
    """Create a file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to create a file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "PipelineFile",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to create a file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_pipeline_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to create a file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> ApiResponse[PipelineFile]

Expand source code

@validate_call
def create_project_pipeline_file_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineFile]:
    """Create a file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to create a file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "PipelineFile",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to create a file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_project_pipeline_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to create a file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_project_pipeline_file_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to create a file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to create a file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "PipelineFile",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to create a file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_additional_project_pipeline_file(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to delete an additional file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> None

Expand source code

@validate_call
def delete_additional_project_pipeline_file(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete an additional file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete an additional input form file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to delete an additional file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_additional_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete an additional input form file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to delete an additional file for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_additional_project_pipeline_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to delete an additional file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_additional_project_pipeline_file_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete an additional file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete an additional input form file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to delete an additional file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_additional_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete an additional input form file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to delete an additional file for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_additional_project_pipeline_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to delete an additional file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_additional_project_pipeline_file_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete an additional file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete an additional input form file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to delete an additional file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_additional_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete an additional input form file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to delete an additional file for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_project_pipeline_file(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to delete a file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> None

Expand source code

@validate_call
def delete_project_pipeline_file(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete a file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete a file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to delete a file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete a file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to delete a file for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_project_pipeline_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to delete a file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_project_pipeline_file_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete a file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete a file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to delete a file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete a file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to delete a file for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_project_pipeline_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to delete a file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_project_pipeline_file_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to delete a file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete a file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to delete a file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete a file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to delete a file for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_additional_file_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the additional file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the additional file')]) ‑> bytearray

Expand source code

@validate_call
def download_additional_file_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the additional file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> bytearray:
    """Download the contents of an additional input form file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the additional file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the additional file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_additional_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Download the contents of an additional input form file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the additional file for (required) :type pipeline_id: str :param file_id: The ID of the additional file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_additional_file_content_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the additional file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the additional file')]) ‑> ApiResponse[bytearray]

Expand source code

@validate_call
def download_additional_file_content_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the additional file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[bytearray]:
    """Download the contents of an additional input form file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the additional file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the additional file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_additional_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Download the contents of an additional input form file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the additional file for (required) :type pipeline_id: str :param file_id: The ID of the additional file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_additional_file_content_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the additional file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the additional file')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def download_additional_file_content_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the additional file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Download the contents of an additional input form file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the additional file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the additional file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_additional_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Download the contents of an additional input form file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the additional file for (required) :type pipeline_id: str :param file_id: The ID of the additional file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_input_form_file_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the input form file for')]) ‑> bytearray

Expand source code

@validate_call
def download_input_form_file_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the input form file for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> bytearray:
    """Download the contents of the input form file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the input form file for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_input_form_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Download the contents of the input form file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the input form file for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_input_form_file_content_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the input form file for')]) ‑> ApiResponse[bytearray]

Expand source code

@validate_call
def download_input_form_file_content_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the input form file for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[bytearray]:
    """Download the contents of the input form file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the input form file for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_input_form_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Download the contents of the input form file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the input form file for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_input_form_file_content_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the input form file for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def download_input_form_file_content_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the input form file for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Download the contents of the input form file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the input form file for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_input_form_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Download the contents of the input form file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the input form file for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_on_render_file_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the onRender file for')]) ‑> bytearray

Expand source code

@validate_call
def download_on_render_file_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onRender file for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> bytearray:
    """Download the contents of the onRender file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the onRender file for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_on_render_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Download the contents of the onRender file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the onRender file for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_on_render_file_content_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the onRender file for')]) ‑> ApiResponse[bytearray]

Expand source code

@validate_call
def download_on_render_file_content_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onRender file for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[bytearray]:
    """Download the contents of the onRender file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the onRender file for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_on_render_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Download the contents of the onRender file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the onRender file for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_on_render_file_content_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the onRender file for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def download_on_render_file_content_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onRender file for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Download the contents of the onRender file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the onRender file for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_on_render_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Download the contents of the onRender file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the onRender file for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_on_submit_file_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the onSubmit file for')]) ‑> bytearray

Expand source code

@validate_call
def download_on_submit_file_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onSubmit file for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> bytearray:
    """Download the contents of the onSubmit file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the onSubmit file for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_on_submit_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Download the contents of the onSubmit file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the onSubmit file for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_on_submit_file_content_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the onSubmit file for')]) ‑> ApiResponse[bytearray]

Expand source code

@validate_call
def download_on_submit_file_content_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onSubmit file for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[bytearray]:
    """Download the contents of the onSubmit file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the onSubmit file for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_on_submit_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Download the contents of the onSubmit file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the onSubmit file for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_on_submit_file_content_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve the onSubmit file for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def download_on_submit_file_content_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve the onSubmit file for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Download the contents of the onSubmit file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve the onSubmit file for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_on_submit_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Download the contents of the onSubmit file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve the onSubmit file for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_project_pipeline_file_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> bytearray

Expand source code

@validate_call
def download_project_pipeline_file_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> bytearray:
    """Download the contents of a pipeline file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_project_pipeline_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Download the contents of a pipeline file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_project_pipeline_file_content_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> ApiResponse[bytearray]

Expand source code

@validate_call
def download_project_pipeline_file_content_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[bytearray]:
    """Download the contents of a pipeline file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_project_pipeline_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Download the contents of a pipeline file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def download_project_pipeline_file_content_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def download_project_pipeline_file_content_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Download the contents of a pipeline file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._download_project_pipeline_file_content_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "bytearray",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Download the contents of a pipeline file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve')]) ‑> ProjectPipelineV4

Expand source code

@validate_call
def get_project_pipeline(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPipelineV4:
    """Retrieve a project pipeline.

    Retrieves a project pipeline. This can be a pipeline from a linked bundle or an entitled, unlinked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project pipeline.

Retrieves a project pipeline. This can be a pipeline from a linked bundle or an entitled, unlinked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_additional_files(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')]) ‑> PipelineFileList

Expand source code

@validate_call
def get_project_pipeline_additional_files(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineFileList:
    """Retrieve additional input form files for a project pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_additional_files_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineFileList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve additional input form files for a project pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_additional_files_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')]) ‑> ApiResponse[PipelineFileList]

Expand source code

@validate_call
def get_project_pipeline_additional_files_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineFileList]:
    """Retrieve additional input form files for a project pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_additional_files_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineFileList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve additional input form files for a project pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_additional_files_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_pipeline_additional_files_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve additional input form files for a project pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_additional_files_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineFileList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve additional input form files for a project pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_configuration_parameters(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve input parameters for')]) ‑> PipelineConfigurationParameterList

Expand source code

@validate_call
def get_project_pipeline_configuration_parameters(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineConfigurationParameterList:
    """Retrieve configuration parameters for a project pipeline.

    The pipeline can originate from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_configuration_parameters_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineConfigurationParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve configuration parameters for a project pipeline.

The pipeline can originate from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_configuration_parameters_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve input parameters for')]) ‑> ApiResponse[PipelineConfigurationParameterList]

Expand source code

@validate_call
def get_project_pipeline_configuration_parameters_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineConfigurationParameterList]:
    """Retrieve configuration parameters for a project pipeline.

    The pipeline can originate from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_configuration_parameters_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineConfigurationParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve configuration parameters for a project pipeline.

The pipeline can originate from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_configuration_parameters_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve input parameters for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_pipeline_configuration_parameters_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve configuration parameters for a project pipeline.

    The pipeline can originate from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_configuration_parameters_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineConfigurationParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve configuration parameters for a project pipeline.

The pipeline can originate from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_files(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')]) ‑> PipelineFileList

Expand source code

@validate_call
def get_project_pipeline_files(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineFileList:
    """Retrieve files for a project pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_files_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineFileList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve files for a project pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_files_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')]) ‑> ApiResponse[PipelineFileList]

Expand source code

@validate_call
def get_project_pipeline_files_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineFileList]:
    """Retrieve files for a project pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_files_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineFileList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve files for a project pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_files_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve files for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_pipeline_files_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve files for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve files for a project pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve files for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_files_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineFileList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve files for a project pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve files for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_html_documentation(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve HTML documentation from')]) ‑> PipelineHtmlDocumentation

Expand source code

@validate_call
def get_project_pipeline_html_documentation(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineHtmlDocumentation:
    """Retrieve HTML documentation for a project pipeline.

    Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_html_documentation_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineHtmlDocumentation",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve HTML documentation for a project pipeline.

Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_html_documentation_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve HTML documentation from')]) ‑> ApiResponse[PipelineHtmlDocumentation]

Expand source code

@validate_call
def get_project_pipeline_html_documentation_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineHtmlDocumentation]:
    """Retrieve HTML documentation for a project pipeline.

    Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_html_documentation_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineHtmlDocumentation",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve HTML documentation for a project pipeline.

Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_html_documentation_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve HTML documentation from')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_pipeline_html_documentation_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve HTML documentation from")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve HTML documentation for a project pipeline.

    Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_html_documentation_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineHtmlDocumentation",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve HTML documentation for a project pipeline.

Retrieve HTML documentation for a project pipeline. This can be a pipeline from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve HTML documentation from (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_input_parameters(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve input parameters for')]) ‑> InputParameterList

Expand source code

@validate_call
def get_project_pipeline_input_parameters(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> InputParameterList:
    """Retrieve input parameters for a project pipeline.

    The pipeline can originate from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_input_parameters_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InputParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve input parameters for a project pipeline.

The pipeline can originate from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_input_parameters_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve input parameters for')]) ‑> ApiResponse[InputParameterList]

Expand source code

@validate_call
def get_project_pipeline_input_parameters_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[InputParameterList]:
    """Retrieve input parameters for a project pipeline.

    The pipeline can originate from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_input_parameters_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InputParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve input parameters for a project pipeline.

The pipeline can originate from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_input_parameters_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve input parameters for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_pipeline_input_parameters_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve input parameters for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve input parameters for a project pipeline.

    The pipeline can originate from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_input_parameters_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "InputParameterList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve input parameters for a project pipeline.

The pipeline can originate from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve input parameters for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_reference_sets(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve reference sets for')]) ‑> ReferenceSetList

Expand source code

@validate_call
def get_project_pipeline_reference_sets(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ReferenceSetList:
    """Retrieve the reference sets of a project pipeline.

    Retrieve the reference sets of a project pipeline. This can be a pipeline from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_reference_sets_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ReferenceSetList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the reference sets of a project pipeline.

Retrieve the reference sets of a project pipeline. This can be a pipeline from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_reference_sets_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve reference sets for')]) ‑> ApiResponse[ReferenceSetList]

Expand source code

@validate_call
def get_project_pipeline_reference_sets_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ReferenceSetList]:
    """Retrieve the reference sets of a project pipeline.

    Retrieve the reference sets of a project pipeline. This can be a pipeline from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_reference_sets_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ReferenceSetList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the reference sets of a project pipeline.

Retrieve the reference sets of a project pipeline. This can be a pipeline from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_reference_sets_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline to retrieve reference sets for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_pipeline_reference_sets_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline to retrieve reference sets for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the reference sets of a project pipeline.

    Retrieve the reference sets of a project pipeline. This can be a pipeline from a linked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_reference_sets_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ReferenceSetList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the reference sets of a project pipeline.

Retrieve the reference sets of a project pipeline. This can be a pipeline from a linked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline to retrieve reference sets for (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve')]) ‑> ApiResponse[ProjectPipelineV4]

Expand source code

@validate_call
def get_project_pipeline_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPipelineV4]:
    """Retrieve a project pipeline.

    Retrieves a project pipeline. This can be a pipeline from a linked bundle or an entitled, unlinked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project pipeline.

Retrieves a project pipeline. This can be a pipeline from a linked bundle or an entitled, unlinked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipeline_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_pipeline_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project pipeline.

    Retrieves a project pipeline. This can be a pipeline from a linked bundle or an entitled, unlinked bundle.

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to retrieve (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipeline_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project pipeline.

Retrieves a project pipeline. This can be a pipeline from a linked bundle or an entitled, unlinked bundle.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to retrieve (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipelines(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to retrieve pipelines for')]) ‑> ProjectPipelineList

Expand source code

@validate_call
def get_project_pipelines(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project to retrieve pipelines for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectPipelineList:
    """Retrieve a list of project pipelines.

    Lists all pipelines that are available to the project.

    :param project_id: The ID of the project to retrieve pipelines for (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipelines_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPipelineList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of project pipelines.

Lists all pipelines that are available to the project.

:param project_id: The ID of the project to retrieve pipelines for (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipelines_with_http_info(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to retrieve pipelines for')]) ‑> ApiResponse[ProjectPipelineList]

Expand source code

@validate_call
def get_project_pipelines_with_http_info(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project to retrieve pipelines for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectPipelineList]:
    """Retrieve a list of project pipelines.

    Lists all pipelines that are available to the project.

    :param project_id: The ID of the project to retrieve pipelines for (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipelines_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPipelineList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of project pipelines.

Lists all pipelines that are available to the project.

:param project_id: The ID of the project to retrieve pipelines for (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_pipelines_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project to retrieve pipelines for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_pipelines_without_preload_content(
    self,
    project_id: Annotated[StrictStr, Field(description="The ID of the project to retrieve pipelines for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of project pipelines.

    Lists all pipelines that are available to the project.

    :param project_id: The ID of the project to retrieve pipelines for (required)
    :type project_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_pipelines_serialize(
        project_id=project_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectPipelineList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of project pipelines.

Lists all pipelines that are available to the project.

:param project_id: The ID of the project to retrieve pipelines for (required) :type project_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_pipeline_to_project(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> None

Expand source code

@validate_call
def link_pipeline_to_project(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Link a pipeline to a project.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_pipeline_to_project_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Link a pipeline to a project.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_pipeline_to_project_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def link_pipeline_to_project_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Link a pipeline to a project.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_pipeline_to_project_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Link a pipeline to a project.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_pipeline_to_project_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def link_pipeline_to_project_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Link a pipeline to a project.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_pipeline_to_project_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Link a pipeline to a project.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def release_project_pipeline(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> None

Expand source code

@validate_call
def release_project_pipeline(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Release a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._release_project_pipeline_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Release a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def release_project_pipeline_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def release_project_pipeline_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Release a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._release_project_pipeline_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Release a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def release_project_pipeline_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def release_project_pipeline_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Release a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._release_project_pipeline_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Release a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_pipeline_from_project(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> None

Expand source code

@validate_call
def unlink_pipeline_from_project(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Unlink a pipeline from a project.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_pipeline_from_project_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Unlink a pipeline from a project.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_pipeline_from_project_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unlink_pipeline_from_project_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Unlink a pipeline from a project.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_pipeline_from_project_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Unlink a pipeline from a project.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_pipeline_from_project_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unlink_pipeline_from_project_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the pipeline")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Unlink a pipeline from a project.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the pipeline (required)
    :type pipeline_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_pipeline_from_project_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Unlink a pipeline from a project.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the pipeline (required) :type pipeline_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_additional_file(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update the additional file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the additional file')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> None

Expand source code

@validate_call
def update_additional_file(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the additional file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Update the contents of an additional input form file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update the additional file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the additional file (required)
    :type file_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_additional_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update the contents of an additional input form file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update the additional file for (required) :type pipeline_id: str :param file_id: The ID of the additional file (required) :type file_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_additional_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update the additional file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the additional file')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def update_additional_file_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the additional file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Update the contents of an additional input form file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update the additional file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the additional file (required)
    :type file_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_additional_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update the contents of an additional input form file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update the additional file for (required) :type pipeline_id: str :param file_id: The ID of the additional file (required) :type file_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_additional_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update the additional file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the additional file')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_additional_file_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the additional file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the additional file")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update the contents of an additional input form file.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update the additional file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the additional file (required)
    :type file_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_additional_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update the contents of an additional input form file.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update the additional file for (required) :type pipeline_id: str :param file_id: The ID of the additional file (required) :type file_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_general_attributes_project_pipeline(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update')],
pipeline_update: PipelineUpdate) ‑> PipelineV4

Expand source code

@validate_call
def update_general_attributes_project_pipeline(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update")],
    pipeline_update: PipelineUpdate,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> PipelineV4:
    """Update the general attributes of a project pipeline.

    Attributes which can be updated: - code - description - languageVersion - proprietary - resources 

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update (required)
    :type pipeline_id: str
    :param pipeline_update: (required)
    :type pipeline_update: PipelineUpdate
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_general_attributes_project_pipeline_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        pipeline_update=pipeline_update,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update the general attributes of a project pipeline.

Attributes which can be updated: - code - description - languageVersion - proprietary - resources

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update (required) :type pipeline_id: str :param pipeline_update: (required) :type pipeline_update: PipelineUpdate :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_general_attributes_project_pipeline_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update')],
pipeline_update: PipelineUpdate) ‑> ApiResponse[PipelineV4]

Expand source code

@validate_call
def update_general_attributes_project_pipeline_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update")],
    pipeline_update: PipelineUpdate,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[PipelineV4]:
    """Update the general attributes of a project pipeline.

    Attributes which can be updated: - code - description - languageVersion - proprietary - resources 

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update (required)
    :type pipeline_id: str
    :param pipeline_update: (required)
    :type pipeline_update: PipelineUpdate
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_general_attributes_project_pipeline_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        pipeline_update=pipeline_update,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update the general attributes of a project pipeline.

Attributes which can be updated: - code - description - languageVersion - proprietary - resources

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update (required) :type pipeline_id: str :param pipeline_update: (required) :type pipeline_update: PipelineUpdate :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_general_attributes_project_pipeline_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update')],
pipeline_update: PipelineUpdate) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_general_attributes_project_pipeline_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update")],
    pipeline_update: PipelineUpdate,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update the general attributes of a project pipeline.

    Attributes which can be updated: - code - description - languageVersion - proprietary - resources 

    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update (required)
    :type pipeline_id: str
    :param pipeline_update: (required)
    :type pipeline_update: PipelineUpdate
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_general_attributes_project_pipeline_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        pipeline_update=pipeline_update,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "PipelineV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update the general attributes of a project pipeline.

Attributes which can be updated: - code - description - languageVersion - proprietary - resources

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update (required) :type pipeline_id: str :param pipeline_update: (required) :type pipeline_update: PipelineUpdate :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_input_form_file(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update a file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> None

Expand source code

@validate_call
def update_input_form_file(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Update the contents of the input form file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update a file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_input_form_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update the contents of the input form file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update a file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_input_form_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update a file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def update_input_form_file_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Update the contents of the input form file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update a file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_input_form_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update the contents of the input form file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update a file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_input_form_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update a file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_input_form_file_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update the contents of the input form file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update a file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_input_form_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update the contents of the input form file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update a file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_on_render_file(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update the onRender file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> None

Expand source code

@validate_call
def update_on_render_file(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onRender file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Update the contents of the onRender file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update the onRender file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_on_render_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update the contents of the onRender file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update the onRender file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_on_render_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update the onRender file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def update_on_render_file_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onRender file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Update the contents of the onRender file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update the onRender file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_on_render_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update the contents of the onRender file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update the onRender file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_on_render_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update the onRender file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_on_render_file_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onRender file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update the contents of the onRender file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update the onRender file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_on_render_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update the contents of the onRender file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update the onRender file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_on_submit_file(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update the onSubmit file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> None

Expand source code

@validate_call
def update_on_submit_file(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onSubmit file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Update the contents of the onSubmit file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update the onSubmit file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_on_submit_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update the contents of the onSubmit file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update the onSubmit file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_on_submit_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update the onSubmit file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def update_on_submit_file_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onSubmit file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Update the contents of the onSubmit file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update the onSubmit file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_on_submit_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update the contents of the onSubmit file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update the onSubmit file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_on_submit_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update the onSubmit file for')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_on_submit_file_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update the onSubmit file for")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update the contents of the onSubmit file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update the onSubmit file for (required)
    :type pipeline_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_on_submit_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update the contents of the onSubmit file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update the onSubmit file for (required) :type pipeline_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_pipeline_file(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update a file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> None

Expand source code

@validate_call
def update_project_pipeline_file(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Update the contents of a file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update a file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update the contents of a file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update a file for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_pipeline_file_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update a file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def update_project_pipeline_file_with_http_info(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Update the contents of a file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update a file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update the contents of a file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update a file for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_pipeline_file_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
pipeline_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the project pipeline to update a file for')],
file_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the pipeline file')],
content: Annotated[bytes, Strict(strict=True)] | Annotated[str, Strict(strict=True)] | Tuple[Annotated[str, Strict(strict=True)], Annotated[bytes, Strict(strict=True)]]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_project_pipeline_file_without_preload_content(
    self,
    project_id: StrictStr,
    pipeline_id: Annotated[StrictStr, Field(description="The ID of the project pipeline to update a file for")],
    file_id: Annotated[StrictStr, Field(description="The ID of the pipeline file")],
    content: Union[StrictBytes, StrictStr, Tuple[StrictStr, StrictBytes]],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update the contents of a file for a pipeline.


    :param project_id: (required)
    :type project_id: str
    :param pipeline_id: The ID of the project pipeline to update a file for (required)
    :type pipeline_id: str
    :param file_id: The ID of the pipeline file (required)
    :type file_id: str
    :param content: (required)
    :type content: bytearray
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_pipeline_file_serialize(
        project_id=project_id,
        pipeline_id=pipeline_id,
        file_id=file_id,
        content=content,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update the contents of a file for a pipeline.

:param project_id: (required) :type project_id: str :param pipeline_id: The ID of the project pipeline to update a file for (required) :type pipeline_id: str :param file_id: The ID of the pipeline file (required) :type file_id: str :param content: (required) :type content: bytearray :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectPipelineList (**data: Any)

Expand source code

class ProjectPipelineList(BaseModel):
    """
    ProjectPipelineList
    """ # noqa: E501
    items: List[ProjectPipeline]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectPipelineList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectPipelineList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectPipeline.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ProjectPipelineList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectPipeline]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectPipelineList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectPipelineList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectPipelineV4 (**data: Any)

Expand source code

class ProjectPipelineV4(BaseModel):
    """
    ProjectPipelineV4
    """ # noqa: E501
    pipeline: PipelineV4
    project_id: StrictStr = Field(alias="projectId")
    bundle_links: BundleList = Field(alias="bundleLinks")
    __properties: ClassVar[List[str]] = ["pipeline", "projectId", "bundleLinks"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectPipelineV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of pipeline
        if self.pipeline:
            _dict['pipeline'] = self.pipeline.to_dict()
        # override the default output from pydantic by calling `to_dict()` of bundle_links
        if self.bundle_links:
            _dict['bundleLinks'] = self.bundle_links.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectPipelineV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "pipeline": PipelineV4.from_dict(obj["pipeline"]) if obj.get("pipeline") is not None else None,
            "projectId": obj.get("projectId"),
            "bundleLinks": BundleList.from_dict(obj["bundleLinks"]) if obj.get("bundleLinks") is not None else None
        })
        return _obj

ProjectPipelineV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bundle_links : BundleList

The type of the None singleton.

var model_config

The type of the None singleton.

var pipeline : PipelineV4

The type of the None singleton.

var project_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectPipelineV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectPipelineV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of pipeline
    if self.pipeline:
        _dict['pipeline'] = self.pipeline.to_dict()
    # override the default output from pydantic by calling `to_dict()` of bundle_links
    if self.bundle_links:
        _dict['bundleLinks'] = self.bundle_links.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectSample (**data: Any)

Expand source code

class ProjectSample(BaseModel):
    """
    ProjectSample
    """ # noqa: E501
    sample: Sample
    project_id: StrictStr = Field(alias="projectId")
    __properties: ClassVar[List[str]] = ["sample", "projectId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectSample from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of sample
        if self.sample:
            _dict['sample'] = self.sample.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectSample from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "sample": Sample.from_dict(obj["sample"]) if obj.get("sample") is not None else None,
            "projectId": obj.get("projectId")
        })
        return _obj

ProjectSample

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var project_id : str

The type of the None singleton.

var sample : Sample

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectSample from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectSample from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of sample
    if self.sample:
        _dict['sample'] = self.sample.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectSampleApi (api_client=None)

Expand source code

class ProjectSampleApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def add_metadata_model_to_sample(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        metadata_model_id: Annotated[StrictStr, Field(description="The ID of the metadata model")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """(Deprecated) Add a metadata model to a sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param metadata_model_id: The ID of the metadata model (required)
        :type metadata_model_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("POST /api/projects/{projectId}/samples/{sampleId}/metadata/{metadataModelId} is deprecated.", DeprecationWarning)

        _param = self._add_metadata_model_to_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            metadata_model_id=metadata_model_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def add_metadata_model_to_sample_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        metadata_model_id: Annotated[StrictStr, Field(description="The ID of the metadata model")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """(Deprecated) Add a metadata model to a sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param metadata_model_id: The ID of the metadata model (required)
        :type metadata_model_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("POST /api/projects/{projectId}/samples/{sampleId}/metadata/{metadataModelId} is deprecated.", DeprecationWarning)

        _param = self._add_metadata_model_to_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            metadata_model_id=metadata_model_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def add_metadata_model_to_sample_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        metadata_model_id: Annotated[StrictStr, Field(description="The ID of the metadata model")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """(Deprecated) Add a metadata model to a sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param metadata_model_id: The ID of the metadata model (required)
        :type metadata_model_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("POST /api/projects/{projectId}/samples/{sampleId}/metadata/{metadataModelId} is deprecated.", DeprecationWarning)

        _param = self._add_metadata_model_to_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            metadata_model_id=metadata_model_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _add_metadata_model_to_sample_serialize(
        self,
        project_id,
        sample_id,
        metadata_model_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        if metadata_model_id is not None:
            _path_params['metadataModelId'] = metadata_model_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/metadata/{metadataModelId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def complete_project_sample(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Completes the sample after data has been linked to it.

        Completes the sample after data has been linked to it. The sample status will be set to 'Available' and a sample completed event will be triggered as well.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._complete_project_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def complete_project_sample_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Completes the sample after data has been linked to it.

        Completes the sample after data has been linked to it. The sample status will be set to 'Available' and a sample completed event will be triggered as well.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._complete_project_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def complete_project_sample_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Completes the sample after data has been linked to it.

        Completes the sample after data has been linked to it. The sample status will be set to 'Available' and a sample completed event will be triggered as well.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._complete_project_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _complete_project_sample_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}:complete',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def create_sample_in_project(
        self,
        project_id: StrictStr,
        create_sample: CreateSample,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectSample:
        """Create a new sample in this project


        :param project_id: (required)
        :type project_id: str
        :param create_sample: (required)
        :type create_sample: CreateSample
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_sample_in_project_serialize(
            project_id=project_id,
            create_sample=create_sample,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_sample_in_project_with_http_info(
        self,
        project_id: StrictStr,
        create_sample: CreateSample,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectSample]:
        """Create a new sample in this project


        :param project_id: (required)
        :type project_id: str
        :param create_sample: (required)
        :type create_sample: CreateSample
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_sample_in_project_serialize(
            project_id=project_id,
            create_sample=create_sample,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_sample_in_project_without_preload_content(
        self,
        project_id: StrictStr,
        create_sample: CreateSample,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a new sample in this project


        :param project_id: (required)
        :type project_id: str
        :param create_sample: (required)
        :type create_sample: CreateSample
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_sample_in_project_serialize(
            project_id=project_id,
            create_sample=create_sample,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_sample_in_project_serialize(
        self,
        project_id,
        create_sample,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_sample is not None:
            _body_params = create_sample


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def deep_delete_sample(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a sample together with all of its data.

        Endpoint deleting a sample together with all of its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._deep_delete_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def deep_delete_sample_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a sample together with all of its data.

        Endpoint deleting a sample together with all of its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._deep_delete_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def deep_delete_sample_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a sample together with all of its data.

        Endpoint deleting a sample together with all of its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._deep_delete_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _deep_delete_sample_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}:deleteDeep',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_and_unlink_sample(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a sample and unlink its data.

        Endpoint for deleting a sample while unlinking its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_and_unlink_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_and_unlink_sample_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a sample and unlink its data.

        Endpoint for deleting a sample while unlinking its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_and_unlink_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_and_unlink_sample_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a sample and unlink its data.

        Endpoint for deleting a sample while unlinking its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_and_unlink_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_and_unlink_sample_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}:deleteUnlink',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def delete_sample_with_input(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Delete a sample as well as its input data.

        Endpoint for deleting a sample as well as its input data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_sample_with_input_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def delete_sample_with_input_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Delete a sample as well as its input data.

        Endpoint for deleting a sample as well as its input data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_sample_with_input_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def delete_sample_with_input_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Delete a sample as well as its input data.

        Endpoint for deleting a sample as well as its input data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._delete_sample_with_input_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _delete_sample_with_input_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}:deleteWithInput',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_sample(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectSample:
        """Retrieve a project sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_sample_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectSample]:
        """Retrieve a project sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_sample_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a project sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_sample_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/samples/{sampleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_sample_analyses(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
        userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
        technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
        referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisPagedListV3:
        """(Deprecated) Retrieve the list of analyses.

        This endpoint only returns V3 items. Use the search endpoint to get V4 items.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param reference: The reference to filter on.
        :type reference: str
        :param userreference: The user-reference to filter on.
        :type userreference: str
        :param status: The status to filter on.
        :type status: str
        :param usertag: The user-tags to filter on.
        :type usertag: str
        :param technicaltag: The technical-tags to filter on.
        :type technicaltag: str
        :param referencetag: The reference-data-tags to filter on.
        :type referencetag: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/samples/{sampleId}/analyses is deprecated.", DeprecationWarning)

        _param = self._get_project_sample_analyses_serialize(
            project_id=project_id,
            sample_id=sample_id,
            reference=reference,
            userreference=userreference,
            status=status,
            usertag=usertag,
            technicaltag=technicaltag,
            referencetag=referencetag,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_sample_analyses_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
        userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
        technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
        referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisPagedListV3]:
        """(Deprecated) Retrieve the list of analyses.

        This endpoint only returns V3 items. Use the search endpoint to get V4 items.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param reference: The reference to filter on.
        :type reference: str
        :param userreference: The user-reference to filter on.
        :type userreference: str
        :param status: The status to filter on.
        :type status: str
        :param usertag: The user-tags to filter on.
        :type usertag: str
        :param technicaltag: The technical-tags to filter on.
        :type technicaltag: str
        :param referencetag: The reference-data-tags to filter on.
        :type referencetag: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/samples/{sampleId}/analyses is deprecated.", DeprecationWarning)

        _param = self._get_project_sample_analyses_serialize(
            project_id=project_id,
            sample_id=sample_id,
            reference=reference,
            userreference=userreference,
            status=status,
            usertag=usertag,
            technicaltag=technicaltag,
            referencetag=referencetag,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_sample_analyses_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
        userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
        technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
        referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """(Deprecated) Retrieve the list of analyses.

        This endpoint only returns V3 items. Use the search endpoint to get V4 items.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param reference: The reference to filter on.
        :type reference: str
        :param userreference: The user-reference to filter on.
        :type userreference: str
        :param status: The status to filter on.
        :type status: str
        :param usertag: The user-tags to filter on.
        :type usertag: str
        :param technicaltag: The technical-tags to filter on.
        :type technicaltag: str
        :param referencetag: The reference-data-tags to filter on.
        :type referencetag: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/samples/{sampleId}/analyses is deprecated.", DeprecationWarning)

        _param = self._get_project_sample_analyses_serialize(
            project_id=project_id,
            sample_id=sample_id,
            reference=reference,
            userreference=userreference,
            status=status,
            usertag=usertag,
            technicaltag=technicaltag,
            referencetag=referencetag,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_sample_analyses_serialize(
        self,
        project_id,
        sample_id,
        reference,
        userreference,
        status,
        usertag,
        technicaltag,
        referencetag,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        if reference is not None:
            
            _query_params.append(('reference', reference))
            
        if userreference is not None:
            
            _query_params.append(('userreference', userreference))
            
        if status is not None:
            
            _query_params.append(('status', status))
            
        if usertag is not None:
            
            _query_params.append(('usertag', usertag))
            
        if technicaltag is not None:
            
            _query_params.append(('technicaltag', technicaltag))
            
        if referencetag is not None:
            
            _query_params.append(('referencetag', referencetag))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/analyses',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_project_samples(
        self,
        project_id: StrictStr,
        find_project_samples: FindProjectSamples,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectSamplePagedList:
        """Retrieve project samples.

        Endpoint for retrieving project samples. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param find_project_samples: (required)
        :type find_project_samples: FindProjectSamples
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_samples_serialize(
            project_id=project_id,
            find_project_samples=find_project_samples,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectSamplePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_project_samples_with_http_info(
        self,
        project_id: StrictStr,
        find_project_samples: FindProjectSamples,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectSamplePagedList]:
        """Retrieve project samples.

        Endpoint for retrieving project samples. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param find_project_samples: (required)
        :type find_project_samples: FindProjectSamples
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_samples_serialize(
            project_id=project_id,
            find_project_samples=find_project_samples,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectSamplePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_project_samples_without_preload_content(
        self,
        project_id: StrictStr,
        find_project_samples: FindProjectSamples,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve project samples.

        Endpoint for retrieving project samples. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param find_project_samples: (required)
        :type find_project_samples: FindProjectSamples
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_project_samples_serialize(
            project_id=project_id,
            find_project_samples=find_project_samples,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectSamplePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_project_samples_serialize(
        self,
        project_id,
        find_project_samples,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if find_project_samples is not None:
            _body_params = find_project_samples


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples:search',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_projects_for_sample(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectList:
        """Retrieve a list of projects for this sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_projects_for_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_projects_for_sample_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectList]:
        """Retrieve a list of projects for this sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_projects_for_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_projects_for_sample_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of projects for this sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_projects_for_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_projects_for_sample_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/projects',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_sample_data_list(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample to retrieve data for")],
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> DataPagedList:
        """Retrieve the list of sample data.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample to retrieve data for (required)
        :type sample_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: List[str]
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: List[str]
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_data_list_serialize(
            project_id=project_id,
            sample_id=sample_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_sample_data_list_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample to retrieve data for")],
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[DataPagedList]:
        """Retrieve the list of sample data.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample to retrieve data for (required)
        :type sample_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: List[str]
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: List[str]
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_data_list_serialize(
            project_id=project_id,
            sample_id=sample_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_sample_data_list_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample to retrieve data for")],
        full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
        filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
        filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
        file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
        file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
        format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
        type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
        parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
        parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
        creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
        user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
        user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
        run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
        run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
        run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
        connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
        connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
        technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
        technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
        not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
        instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the list of sample data.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample to retrieve data for (required)
        :type sample_id: str
        :param full_text: To search through multiple fields of data.
        :type full_text: str
        :param id: The ids to filter on. This will always match exact.
        :type id: List[str]
        :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
        :type filename: List[str]
        :param filename_match_mode: How the filenames are filtered. 
        :type filename_match_mode: str
        :param file_path: The paths of the files to filter on.
        :type file_path: List[str]
        :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
        :type file_path_match_mode: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param format_id: The IDs of the formats to filter on.
        :type format_id: List[str]
        :param format_code: The codes of the formats to filter on.
        :type format_code: List[str]
        :param type: The type to filter on.
        :type type: str
        :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
        :type parent_folder_id: List[str]
        :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
        :type parent_folder_path: str
        :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_after: datetime
        :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type creation_date_before: datetime
        :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_after: datetime
        :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
        :type status_date_before: datetime
        :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
        :type user_tag: List[str]
        :param user_tag_match_mode: How the usertags are filtered. 
        :type user_tag_match_mode: str
        :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
        :type run_input_tag: List[str]
        :param run_input_tag_match_mode: How the runInputTags are filtered. 
        :type run_input_tag_match_mode: str
        :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
        :type run_output_tag: List[str]
        :param run_output_tag_match_mode: How the runOutputTags are filtered. 
        :type run_output_tag_match_mode: str
        :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
        :type connector_tag: List[str]
        :param connector_tag_match_mode: How the connectorTags are filtered. 
        :type connector_tag_match_mode: str
        :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
        :type technical_tag: List[str]
        :param technical_tag_match_mode: How the technicalTags are filtered. 
        :type technical_tag_match_mode: str
        :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
        :type not_in_run: bool
        :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
        :type instrument_run_id: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_data_list_serialize(
            project_id=project_id,
            sample_id=sample_id,
            full_text=full_text,
            id=id,
            filename=filename,
            filename_match_mode=filename_match_mode,
            file_path=file_path,
            file_path_match_mode=file_path_match_mode,
            status=status,
            format_id=format_id,
            format_code=format_code,
            type=type,
            parent_folder_id=parent_folder_id,
            parent_folder_path=parent_folder_path,
            creation_date_after=creation_date_after,
            creation_date_before=creation_date_before,
            status_date_after=status_date_after,
            status_date_before=status_date_before,
            user_tag=user_tag,
            user_tag_match_mode=user_tag_match_mode,
            run_input_tag=run_input_tag,
            run_input_tag_match_mode=run_input_tag_match_mode,
            run_output_tag=run_output_tag,
            run_output_tag_match_mode=run_output_tag_match_mode,
            connector_tag=connector_tag,
            connector_tag_match_mode=connector_tag_match_mode,
            technical_tag=technical_tag,
            technical_tag_match_mode=technical_tag_match_mode,
            not_in_run=not_in_run,
            instrument_run_id=instrument_run_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "DataPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_sample_data_list_serialize(
        self,
        project_id,
        sample_id,
        full_text,
        id,
        filename,
        filename_match_mode,
        file_path,
        file_path_match_mode,
        status,
        format_id,
        format_code,
        type,
        parent_folder_id,
        parent_folder_path,
        creation_date_after,
        creation_date_before,
        status_date_after,
        status_date_before,
        user_tag,
        user_tag_match_mode,
        run_input_tag,
        run_input_tag_match_mode,
        run_output_tag,
        run_output_tag_match_mode,
        connector_tag,
        connector_tag_match_mode,
        technical_tag,
        technical_tag_match_mode,
        not_in_run,
        instrument_run_id,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'id': 'multi',
            'filename': 'multi',
            'filePath': 'multi',
            'status': 'multi',
            'formatId': 'multi',
            'formatCode': 'multi',
            'parentFolderId': 'multi',
            'userTag': 'multi',
            'runInputTag': 'multi',
            'runOutputTag': 'multi',
            'connectorTag': 'multi',
            'technicalTag': 'multi',
            'instrumentRunId': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        if full_text is not None:
            
            _query_params.append(('fullText', full_text))
            
        if id is not None:
            
            _query_params.append(('id', id))
            
        if filename is not None:
            
            _query_params.append(('filename', filename))
            
        if filename_match_mode is not None:
            
            _query_params.append(('filenameMatchMode', filename_match_mode))
            
        if file_path is not None:
            
            _query_params.append(('filePath', file_path))
            
        if file_path_match_mode is not None:
            
            _query_params.append(('filePathMatchMode', file_path_match_mode))
            
        if status is not None:
            
            _query_params.append(('status', status))
            
        if format_id is not None:
            
            _query_params.append(('formatId', format_id))
            
        if format_code is not None:
            
            _query_params.append(('formatCode', format_code))
            
        if type is not None:
            
            _query_params.append(('type', type))
            
        if parent_folder_id is not None:
            
            _query_params.append(('parentFolderId', parent_folder_id))
            
        if parent_folder_path is not None:
            
            _query_params.append(('parentFolderPath', parent_folder_path))
            
        if creation_date_after is not None:
            if isinstance(creation_date_after, datetime):
                _query_params.append(
                    (
                        'creationDateAfter',
                        creation_date_after.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('creationDateAfter', creation_date_after))
            
        if creation_date_before is not None:
            if isinstance(creation_date_before, datetime):
                _query_params.append(
                    (
                        'creationDateBefore',
                        creation_date_before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('creationDateBefore', creation_date_before))
            
        if status_date_after is not None:
            if isinstance(status_date_after, datetime):
                _query_params.append(
                    (
                        'statusDateAfter',
                        status_date_after.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('statusDateAfter', status_date_after))
            
        if status_date_before is not None:
            if isinstance(status_date_before, datetime):
                _query_params.append(
                    (
                        'statusDateBefore',
                        status_date_before.strftime(
                            self.api_client.configuration.datetime_format
                        )
                    )
                )
            else:
                _query_params.append(('statusDateBefore', status_date_before))
            
        if user_tag is not None:
            
            _query_params.append(('userTag', user_tag))
            
        if user_tag_match_mode is not None:
            
            _query_params.append(('userTagMatchMode', user_tag_match_mode))
            
        if run_input_tag is not None:
            
            _query_params.append(('runInputTag', run_input_tag))
            
        if run_input_tag_match_mode is not None:
            
            _query_params.append(('runInputTagMatchMode', run_input_tag_match_mode))
            
        if run_output_tag is not None:
            
            _query_params.append(('runOutputTag', run_output_tag))
            
        if run_output_tag_match_mode is not None:
            
            _query_params.append(('runOutputTagMatchMode', run_output_tag_match_mode))
            
        if connector_tag is not None:
            
            _query_params.append(('connectorTag', connector_tag))
            
        if connector_tag_match_mode is not None:
            
            _query_params.append(('connectorTagMatchMode', connector_tag_match_mode))
            
        if technical_tag is not None:
            
            _query_params.append(('technicalTag', technical_tag))
            
        if technical_tag_match_mode is not None:
            
            _query_params.append(('technicalTagMatchMode', technical_tag_match_mode))
            
        if not_in_run is not None:
            
            _query_params.append(('notInRun', not_in_run))
            
        if instrument_run_id is not None:
            
            _query_params.append(('instrumentRunId', instrument_run_id))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/data',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_sample_history(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> SampleHistoryList:
        """Retrieve sample history.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_history_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleHistoryList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_sample_history_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[SampleHistoryList]:
        """Retrieve sample history.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_history_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleHistoryList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_sample_history_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve sample history.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_history_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleHistoryList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_sample_history_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/history',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_sample_metadata_field(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        field_id: Annotated[StrictStr, Field(description="The ID of the field")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ModelField:
        """Retrieve a metadata field.

        Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param field_id: The ID of the field (required)
        :type field_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_metadata_field_serialize(
            project_id=project_id,
            sample_id=sample_id,
            field_id=field_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ModelField",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_sample_metadata_field_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        field_id: Annotated[StrictStr, Field(description="The ID of the field")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ModelField]:
        """Retrieve a metadata field.

        Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param field_id: The ID of the field (required)
        :type field_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_metadata_field_serialize(
            project_id=project_id,
            sample_id=sample_id,
            field_id=field_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ModelField",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_sample_metadata_field_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        field_id: Annotated[StrictStr, Field(description="The ID of the field")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a metadata field.

        Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param field_id: The ID of the field (required)
        :type field_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_metadata_field_serialize(
            project_id=project_id,
            sample_id=sample_id,
            field_id=field_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ModelField",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_sample_metadata_field_serialize(
        self,
        project_id,
        sample_id,
        field_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        if field_id is not None:
            _path_params['fieldId'] = field_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/metadata/field/{fieldId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_sample_metadata_field_count(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        field_id: Annotated[StrictStr, Field(description="The ID of the field")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ModelField:
        """Retrieves the number of occurrences of a given field.

        Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param field_id: The ID of the field (required)
        :type field_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_metadata_field_count_serialize(
            project_id=project_id,
            sample_id=sample_id,
            field_id=field_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ModelField",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_sample_metadata_field_count_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        field_id: Annotated[StrictStr, Field(description="The ID of the field")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ModelField]:
        """Retrieves the number of occurrences of a given field.

        Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param field_id: The ID of the field (required)
        :type field_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_metadata_field_count_serialize(
            project_id=project_id,
            sample_id=sample_id,
            field_id=field_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ModelField",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_sample_metadata_field_count_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        field_id: Annotated[StrictStr, Field(description="The ID of the field")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieves the number of occurrences of a given field.

        Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param field_id: The ID of the field (required)
        :type field_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_metadata_field_count_serialize(
            project_id=project_id,
            sample_id=sample_id,
            field_id=field_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ModelField",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_sample_metadata_field_count_serialize(
        self,
        project_id,
        sample_id,
        field_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        if field_id is not None:
            _path_params['fieldId'] = field_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/metadata/{fieldId}/fieldCount',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def link_data_to_sample(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        data_id: Annotated[StrictStr, Field(description="The ID of the data to link")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Link data to a sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param data_id: The ID of the data to link (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_data_to_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def link_data_to_sample_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        data_id: Annotated[StrictStr, Field(description="The ID of the data to link")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Link data to a sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param data_id: The ID of the data to link (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_data_to_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def link_data_to_sample_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        data_id: Annotated[StrictStr, Field(description="The ID of the data to link")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Link data to a sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param data_id: The ID of the data to link (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_data_to_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _link_data_to_sample_serialize(
        self,
        project_id,
        sample_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/data/{dataId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def link_sample_to_project(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectSample:
        """Link a sample to a project.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_sample_to_project_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def link_sample_to_project_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectSample]:
        """Link a sample to a project.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_sample_to_project_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def link_sample_to_project_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Link a sample to a project.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._link_sample_to_project_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _link_sample_to_project_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def mark_sample_deleted(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Mark a sample deleted.

        Endpoint for marking a sample as deleted.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._mark_sample_deleted_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def mark_sample_deleted_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Mark a sample deleted.

        Endpoint for marking a sample as deleted.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._mark_sample_deleted_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def mark_sample_deleted_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Mark a sample deleted.

        Endpoint for marking a sample as deleted.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._mark_sample_deleted_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _mark_sample_deleted_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}:deleteMark',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def search_project_sample_analyses(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> AnalysisPagedListV4:
        """Search analyses for sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_project_sample_analyses_serialize(
            project_id=project_id,
            sample_id=sample_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def search_project_sample_analyses_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[AnalysisPagedListV4]:
        """Search analyses for sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_project_sample_analyses_serialize(
            project_id=project_id,
            sample_id=sample_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def search_project_sample_analyses_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Search analyses for sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_project_sample_analyses_serialize(
            project_id=project_id,
            sample_id=sample_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "AnalysisPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _search_project_sample_analyses_serialize(
        self,
        project_id,
        sample_id,
        page_offset,
        page_token,
        page_size,
        sort,
        analysis_query_parameters,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if analysis_query_parameters is not None:
            _body_params = analysis_query_parameters


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/analyses:search',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unlink_data_from_sample(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        data_id: Annotated[StrictStr, Field(description="The ID of the data to unlink")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Unlink data from a sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param data_id: The ID of the data to unlink (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_data_from_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unlink_data_from_sample_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        data_id: Annotated[StrictStr, Field(description="The ID of the data to unlink")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Unlink data from a sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param data_id: The ID of the data to unlink (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_data_from_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unlink_data_from_sample_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
        data_id: Annotated[StrictStr, Field(description="The ID of the data to unlink")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Unlink data from a sample.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: The ID of the sample (required)
        :type sample_id: str
        :param data_id: The ID of the data to unlink (required)
        :type data_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_data_from_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            data_id=data_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unlink_data_from_sample_serialize(
        self,
        project_id,
        sample_id,
        data_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        if data_id is not None:
            _path_params['dataId'] = data_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/data/{dataId}:unlink',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def unlink_sample_from_project(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Unlink a sample from a project.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_sample_from_project_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def unlink_sample_from_project_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Unlink a sample from a project.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_sample_from_project_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def unlink_sample_from_project_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Unlink a sample from a project.


        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._unlink_sample_from_project_serialize(
            project_id=project_id,
            sample_id=sample_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _unlink_sample_from_project_serialize(
        self,
        project_id,
        sample_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}:unlink',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_project_sample(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        project_sample: ProjectSample,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ProjectSample:
        """Update a project sample.

        Fields which can be updated: - sample.name - sample.description - sample.status - sample.tags

        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param project_sample: (required)
        :type project_sample: ProjectSample
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            project_sample=project_sample,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_project_sample_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        project_sample: ProjectSample,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ProjectSample]:
        """Update a project sample.

        Fields which can be updated: - sample.name - sample.description - sample.status - sample.tags

        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param project_sample: (required)
        :type project_sample: ProjectSample
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            project_sample=project_sample,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_project_sample_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        project_sample: ProjectSample,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a project sample.

        Fields which can be updated: - sample.name - sample.description - sample.status - sample.tags

        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param project_sample: (required)
        :type project_sample: ProjectSample
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_project_sample_serialize(
            project_id=project_id,
            sample_id=sample_id,
            project_sample=project_sample,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ProjectSample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_project_sample_serialize(
        self,
        project_id,
        sample_id,
        project_sample,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if project_sample is not None:
            _body_params = project_sample


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/projects/{projectId}/samples/{sampleId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_sample_metadata_fields(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        update_metadata: UpdateMetadata,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Sample:
        """Update metadata fields.

        Endpoint for updating metadata fields.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param update_metadata: (required)
        :type update_metadata: UpdateMetadata
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_sample_metadata_fields_serialize(
            project_id=project_id,
            sample_id=sample_id,
            update_metadata=update_metadata,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': "Sample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_sample_metadata_fields_with_http_info(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        update_metadata: UpdateMetadata,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Sample]:
        """Update metadata fields.

        Endpoint for updating metadata fields.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param update_metadata: (required)
        :type update_metadata: UpdateMetadata
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_sample_metadata_fields_serialize(
            project_id=project_id,
            sample_id=sample_id,
            update_metadata=update_metadata,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': "Sample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_sample_metadata_fields_without_preload_content(
        self,
        project_id: StrictStr,
        sample_id: StrictStr,
        update_metadata: UpdateMetadata,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update metadata fields.

        Endpoint for updating metadata fields.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param project_id: (required)
        :type project_id: str
        :param sample_id: (required)
        :type sample_id: str
        :param update_metadata: (required)
        :type update_metadata: UpdateMetadata
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_sample_metadata_fields_serialize(
            project_id=project_id,
            sample_id=sample_id,
            update_metadata=update_metadata,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': "Sample",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_sample_metadata_fields_serialize(
        self,
        project_id,
        sample_id,
        update_metadata,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if sample_id is not None:
            _path_params['sampleId'] = sample_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if update_metadata is not None:
            _body_params = update_metadata


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/samples/{sampleId}/metadata:updateFields',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def add_metadata_model_to_sample(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
metadata_model_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the metadata model')]) ‑> None

Expand source code

@validate_call
def add_metadata_model_to_sample(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    metadata_model_id: Annotated[StrictStr, Field(description="The ID of the metadata model")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """(Deprecated) Add a metadata model to a sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param metadata_model_id: The ID of the metadata model (required)
    :type metadata_model_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("POST /api/projects/{projectId}/samples/{sampleId}/metadata/{metadataModelId} is deprecated.", DeprecationWarning)

    _param = self._add_metadata_model_to_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        metadata_model_id=metadata_model_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

(Deprecated) Add a metadata model to a sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param metadata_model_id: The ID of the metadata model (required) :type metadata_model_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def add_metadata_model_to_sample_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
metadata_model_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the metadata model')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def add_metadata_model_to_sample_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    metadata_model_id: Annotated[StrictStr, Field(description="The ID of the metadata model")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """(Deprecated) Add a metadata model to a sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param metadata_model_id: The ID of the metadata model (required)
    :type metadata_model_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("POST /api/projects/{projectId}/samples/{sampleId}/metadata/{metadataModelId} is deprecated.", DeprecationWarning)

    _param = self._add_metadata_model_to_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        metadata_model_id=metadata_model_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

(Deprecated) Add a metadata model to a sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param metadata_model_id: The ID of the metadata model (required) :type metadata_model_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def add_metadata_model_to_sample_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
metadata_model_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the metadata model')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def add_metadata_model_to_sample_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    metadata_model_id: Annotated[StrictStr, Field(description="The ID of the metadata model")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Add a metadata model to a sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param metadata_model_id: The ID of the metadata model (required)
    :type metadata_model_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("POST /api/projects/{projectId}/samples/{sampleId}/metadata/{metadataModelId} is deprecated.", DeprecationWarning)

    _param = self._add_metadata_model_to_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        metadata_model_id=metadata_model_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

(Deprecated) Add a metadata model to a sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param metadata_model_id: The ID of the metadata model (required) :type metadata_model_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def complete_project_sample(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def complete_project_sample(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Completes the sample after data has been linked to it.

    Completes the sample after data has been linked to it. The sample status will be set to 'Available' and a sample completed event will be triggered as well.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._complete_project_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Completes the sample after data has been linked to it.

Completes the sample after data has been linked to it. The sample status will be set to 'Available' and a sample completed event will be triggered as well.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def complete_project_sample_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def complete_project_sample_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Completes the sample after data has been linked to it.

    Completes the sample after data has been linked to it. The sample status will be set to 'Available' and a sample completed event will be triggered as well.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._complete_project_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Completes the sample after data has been linked to it.

Completes the sample after data has been linked to it. The sample status will be set to 'Available' and a sample completed event will be triggered as well.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def complete_project_sample_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def complete_project_sample_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Completes the sample after data has been linked to it.

    Completes the sample after data has been linked to it. The sample status will be set to 'Available' and a sample completed event will be triggered as well.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._complete_project_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Completes the sample after data has been linked to it.

Completes the sample after data has been linked to it. The sample status will be set to 'Available' and a sample completed event will be triggered as well.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_sample_in_project(self,
project_id: Annotated[str, Strict(strict=True)],
create_sample: CreateSample) ‑> ProjectSample

Expand source code

@validate_call
def create_sample_in_project(
    self,
    project_id: StrictStr,
    create_sample: CreateSample,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectSample:
    """Create a new sample in this project


    :param project_id: (required)
    :type project_id: str
    :param create_sample: (required)
    :type create_sample: CreateSample
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_sample_in_project_serialize(
        project_id=project_id,
        create_sample=create_sample,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a new sample in this project

:param project_id: (required) :type project_id: str :param create_sample: (required) :type create_sample: CreateSample :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_sample_in_project_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_sample: CreateSample) ‑> ApiResponse[ProjectSample]

Expand source code

@validate_call
def create_sample_in_project_with_http_info(
    self,
    project_id: StrictStr,
    create_sample: CreateSample,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectSample]:
    """Create a new sample in this project


    :param project_id: (required)
    :type project_id: str
    :param create_sample: (required)
    :type create_sample: CreateSample
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_sample_in_project_serialize(
        project_id=project_id,
        create_sample=create_sample,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a new sample in this project

:param project_id: (required) :type project_id: str :param create_sample: (required) :type create_sample: CreateSample :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_sample_in_project_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_sample: CreateSample) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_sample_in_project_without_preload_content(
    self,
    project_id: StrictStr,
    create_sample: CreateSample,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a new sample in this project


    :param project_id: (required)
    :type project_id: str
    :param create_sample: (required)
    :type create_sample: CreateSample
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_sample_in_project_serialize(
        project_id=project_id,
        create_sample=create_sample,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a new sample in this project

:param project_id: (required) :type project_id: str :param create_sample: (required) :type create_sample: CreateSample :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def deep_delete_sample(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> None

Expand source code

@validate_call
def deep_delete_sample(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete a sample together with all of its data.

    Endpoint deleting a sample together with all of its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._deep_delete_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete a sample together with all of its data.

Endpoint deleting a sample together with all of its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def deep_delete_sample_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def deep_delete_sample_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete a sample together with all of its data.

    Endpoint deleting a sample together with all of its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._deep_delete_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete a sample together with all of its data.

Endpoint deleting a sample together with all of its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def deep_delete_sample_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def deep_delete_sample_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete a sample together with all of its data.

    Endpoint deleting a sample together with all of its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._deep_delete_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete a sample together with all of its data.

Endpoint deleting a sample together with all of its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_and_unlink_sample(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> None

Expand source code

@validate_call
def delete_and_unlink_sample(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete a sample and unlink its data.

    Endpoint for deleting a sample while unlinking its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_and_unlink_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete a sample and unlink its data.

Endpoint for deleting a sample while unlinking its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_and_unlink_sample_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_and_unlink_sample_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete a sample and unlink its data.

    Endpoint for deleting a sample while unlinking its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_and_unlink_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete a sample and unlink its data.

Endpoint for deleting a sample while unlinking its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_and_unlink_sample_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_and_unlink_sample_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete a sample and unlink its data.

    Endpoint for deleting a sample while unlinking its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_and_unlink_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete a sample and unlink its data.

Endpoint for deleting a sample while unlinking its data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_sample_with_input(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> None

Expand source code

@validate_call
def delete_sample_with_input(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Delete a sample as well as its input data.

    Endpoint for deleting a sample as well as its input data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_sample_with_input_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Delete a sample as well as its input data.

Endpoint for deleting a sample as well as its input data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_sample_with_input_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def delete_sample_with_input_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Delete a sample as well as its input data.

    Endpoint for deleting a sample as well as its input data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_sample_with_input_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Delete a sample as well as its input data.

Endpoint for deleting a sample as well as its input data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def delete_sample_with_input_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def delete_sample_with_input_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Delete a sample as well as its input data.

    Endpoint for deleting a sample as well as its input data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._delete_sample_with_input_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Delete a sample as well as its input data.

Endpoint for deleting a sample as well as its input data.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_sample(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> ProjectSample

Expand source code

@validate_call
def get_project_sample(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectSample:
    """Retrieve a project sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a project sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_sample_analyses(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
reference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference to filter on.')] = None,
userreference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-reference to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
usertag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-tags to filter on.')] = None,
technicaltag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical-tags to filter on.')] = None,
referencetag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference-data-tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None) ‑> AnalysisPagedListV3

Expand source code

@validate_call
def get_project_sample_analyses(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
    userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
    technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
    referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisPagedListV3:
    """(Deprecated) Retrieve the list of analyses.

    This endpoint only returns V3 items. Use the search endpoint to get V4 items.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param reference: The reference to filter on.
    :type reference: str
    :param userreference: The user-reference to filter on.
    :type userreference: str
    :param status: The status to filter on.
    :type status: str
    :param usertag: The user-tags to filter on.
    :type usertag: str
    :param technicaltag: The technical-tags to filter on.
    :type technicaltag: str
    :param referencetag: The reference-data-tags to filter on.
    :type referencetag: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/samples/{sampleId}/analyses is deprecated.", DeprecationWarning)

    _param = self._get_project_sample_analyses_serialize(
        project_id=project_id,
        sample_id=sample_id,
        reference=reference,
        userreference=userreference,
        status=status,
        usertag=usertag,
        technicaltag=technicaltag,
        referencetag=referencetag,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

(Deprecated) Retrieve the list of analyses.

This endpoint only returns V3 items. Use the search endpoint to get V4 items.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param reference: The reference to filter on. :type reference: str :param userreference: The user-reference to filter on. :type userreference: str :param status: The status to filter on. :type status: str :param usertag: The user-tags to filter on. :type usertag: str :param technicaltag: The technical-tags to filter on. :type technicaltag: str :param referencetag: The reference-data-tags to filter on. :type referencetag: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_sample_analyses_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
reference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference to filter on.')] = None,
userreference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-reference to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
usertag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-tags to filter on.')] = None,
technicaltag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical-tags to filter on.')] = None,
referencetag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference-data-tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None) ‑> ApiResponse[AnalysisPagedListV3]

Expand source code

@validate_call
def get_project_sample_analyses_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
    userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
    technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
    referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisPagedListV3]:
    """(Deprecated) Retrieve the list of analyses.

    This endpoint only returns V3 items. Use the search endpoint to get V4 items.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param reference: The reference to filter on.
    :type reference: str
    :param userreference: The user-reference to filter on.
    :type userreference: str
    :param status: The status to filter on.
    :type status: str
    :param usertag: The user-tags to filter on.
    :type usertag: str
    :param technicaltag: The technical-tags to filter on.
    :type technicaltag: str
    :param referencetag: The reference-data-tags to filter on.
    :type referencetag: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/samples/{sampleId}/analyses is deprecated.", DeprecationWarning)

    _param = self._get_project_sample_analyses_serialize(
        project_id=project_id,
        sample_id=sample_id,
        reference=reference,
        userreference=userreference,
        status=status,
        usertag=usertag,
        technicaltag=technicaltag,
        referencetag=referencetag,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

(Deprecated) Retrieve the list of analyses.

This endpoint only returns V3 items. Use the search endpoint to get V4 items.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param reference: The reference to filter on. :type reference: str :param userreference: The user-reference to filter on. :type userreference: str :param status: The status to filter on. :type status: str :param usertag: The user-tags to filter on. :type usertag: str :param technicaltag: The technical-tags to filter on. :type technicaltag: str :param referencetag: The reference-data-tags to filter on. :type referencetag: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_sample_analyses_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
reference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference to filter on.')] = None,
userreference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-reference to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
usertag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-tags to filter on.')] = None,
technicaltag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical-tags to filter on.')] = None,
referencetag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference-data-tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_sample_analyses_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
    userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
    technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
    referencetag: Annotated[Optional[StrictStr], Field(description="The reference-data-tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Retrieve the list of analyses.

    This endpoint only returns V3 items. Use the search endpoint to get V4 items.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param reference: The reference to filter on.
    :type reference: str
    :param userreference: The user-reference to filter on.
    :type userreference: str
    :param status: The status to filter on.
    :type status: str
    :param usertag: The user-tags to filter on.
    :type usertag: str
    :param technicaltag: The technical-tags to filter on.
    :type technicaltag: str
    :param referencetag: The reference-data-tags to filter on.
    :type referencetag: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/samples/{sampleId}/analyses is deprecated.", DeprecationWarning)

    _param = self._get_project_sample_analyses_serialize(
        project_id=project_id,
        sample_id=sample_id,
        reference=reference,
        userreference=userreference,
        status=status,
        usertag=usertag,
        technicaltag=technicaltag,
        referencetag=referencetag,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

(Deprecated) Retrieve the list of analyses.

This endpoint only returns V3 items. Use the search endpoint to get V4 items.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param reference: The reference to filter on. :type reference: str :param userreference: The user-reference to filter on. :type userreference: str :param status: The status to filter on. :type status: str :param usertag: The user-tags to filter on. :type usertag: str :param technicaltag: The technical-tags to filter on. :type technicaltag: str :param referencetag: The reference-data-tags to filter on. :type referencetag: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_sample_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> ApiResponse[ProjectSample]

Expand source code

@validate_call
def get_project_sample_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectSample]:
    """Retrieve a project sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a project sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_sample_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_sample_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a project sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a project sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_samples(self,
project_id: Annotated[str, Strict(strict=True)],
find_project_samples: FindProjectSamples,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status')] = None) ‑> ProjectSamplePagedList

Expand source code

@validate_call
def get_project_samples(
    self,
    project_id: StrictStr,
    find_project_samples: FindProjectSamples,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectSamplePagedList:
    """Retrieve project samples.

    Endpoint for retrieving project samples. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param find_project_samples: (required)
    :type find_project_samples: FindProjectSamples
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_samples_serialize(
        project_id=project_id,
        find_project_samples=find_project_samples,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectSamplePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve project samples.

Endpoint for retrieving project samples. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param find_project_samples: (required) :type find_project_samples: FindProjectSamples :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_samples_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
find_project_samples: FindProjectSamples,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status')] = None) ‑> ApiResponse[ProjectSamplePagedList]

Expand source code

@validate_call
def get_project_samples_with_http_info(
    self,
    project_id: StrictStr,
    find_project_samples: FindProjectSamples,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectSamplePagedList]:
    """Retrieve project samples.

    Endpoint for retrieving project samples. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param find_project_samples: (required)
    :type find_project_samples: FindProjectSamples
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_samples_serialize(
        project_id=project_id,
        find_project_samples=find_project_samples,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectSamplePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve project samples.

Endpoint for retrieving project samples. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param find_project_samples: (required) :type find_project_samples: FindProjectSamples :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_project_samples_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
find_project_samples: FindProjectSamples,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_project_samples_without_preload_content(
    self,
    project_id: StrictStr,
    find_project_samples: FindProjectSamples,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve project samples.

    Endpoint for retrieving project samples. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param find_project_samples: (required)
    :type find_project_samples: FindProjectSamples
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_project_samples_serialize(
        project_id=project_id,
        find_project_samples=find_project_samples,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectSamplePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve project samples.

Endpoint for retrieving project samples. This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param find_project_samples: (required) :type find_project_samples: FindProjectSamples :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_projects_for_sample(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> ProjectList

Expand source code

@validate_call
def get_projects_for_sample(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectList:
    """Retrieve a list of projects for this sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_projects_for_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of projects for this sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_projects_for_sample_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> ApiResponse[ProjectList]

Expand source code

@validate_call
def get_projects_for_sample_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectList]:
    """Retrieve a list of projects for this sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_projects_for_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of projects for this sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_projects_for_sample_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_projects_for_sample_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of projects for this sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_projects_for_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of projects for this sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_data_list(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample to retrieve data for')],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
file_path: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
parent_folder_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> DataPagedList

Expand source code

@validate_call
def get_sample_data_list(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample to retrieve data for")],
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> DataPagedList:
    """Retrieve the list of sample data.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample to retrieve data for (required)
    :type sample_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: List[str]
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: List[str]
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_data_list_serialize(
        project_id=project_id,
        sample_id=sample_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the list of sample data.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample to retrieve data for (required) :type sample_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: List[str] :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: List[str] :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_data_list_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample to retrieve data for')],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
file_path: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
parent_folder_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> ApiResponse[DataPagedList]

Expand source code

@validate_call
def get_sample_data_list_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample to retrieve data for")],
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[DataPagedList]:
    """Retrieve the list of sample data.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample to retrieve data for (required)
    :type sample_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: List[str]
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: List[str]
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_data_list_serialize(
        project_id=project_id,
        sample_id=sample_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the list of sample data.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample to retrieve data for (required) :type sample_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: List[str] :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: List[str] :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_data_list_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample to retrieve data for')],
full_text: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The ids to filter on. This will always match exact.')] = None,
filename: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.')] = None,
filename_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the filenames are filtered. ')] = None,
file_path: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The paths of the files to filter on.')] = None,
file_path_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
format_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of the formats to filter on.')] = None,
format_code: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The codes of the formats to filter on.')] = None,
type: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The type to filter on.')] = None,
parent_folder_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.')] = None,
parent_folder_path: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
creation_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
creation_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_after: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
status_date_before: Annotated[datetime.datetime | None, FieldInfo(annotation=NoneType, required=True, description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
user_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.')] = None,
user_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the usertags are filtered. ')] = None,
run_input_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_input_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runInputTags are filtered. ')] = None,
run_output_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.')] = None,
run_output_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the runOutputTags are filtered. ')] = None,
connector_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.')] = None,
connector_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the connectorTags are filtered. ')] = None,
technical_tag: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.')] = None,
technical_tag_match_mode: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='How the technicalTags are filtered. ')] = None,
not_in_run: Annotated[Annotated[bool, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='When set to true, the data will be filtered on data which is not used in a run.')] = None,
instrument_run_id: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The instrument run IDs of the sequencing runs to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_sample_data_list_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample to retrieve data for")],
    full_text: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    id: Annotated[Optional[List[StrictStr]], Field(description="The ids to filter on. This will always match exact.")] = None,
    filename: Annotated[Optional[List[StrictStr]], Field(description="The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.")] = None,
    filename_match_mode: Annotated[Optional[StrictStr], Field(description="How the filenames are filtered. ")] = None,
    file_path: Annotated[Optional[List[StrictStr]], Field(description="The paths of the files to filter on.")] = None,
    file_path_match_mode: Annotated[Optional[StrictStr], Field(description="How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).")] = None,
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    format_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of the formats to filter on.")] = None,
    format_code: Annotated[Optional[List[StrictStr]], Field(description="The codes of the formats to filter on.")] = None,
    type: Annotated[Optional[StrictStr], Field(description="The type to filter on.")] = None,
    parent_folder_id: Annotated[Optional[List[StrictStr]], Field(description="The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.")] = None,
    parent_folder_path: Annotated[Optional[StrictStr], Field(description="The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.")] = None,
    creation_date_after: Annotated[Optional[datetime], Field(description="The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    creation_date_before: Annotated[Optional[datetime], Field(description="The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_after: Annotated[Optional[datetime], Field(description="The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    status_date_before: Annotated[Optional[datetime], Field(description="The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z")] = None,
    user_tag: Annotated[Optional[List[StrictStr]], Field(description="The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.")] = None,
    user_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the usertags are filtered. ")] = None,
    run_input_tag: Annotated[Optional[List[StrictStr]], Field(description="The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_input_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runInputTags are filtered. ")] = None,
    run_output_tag: Annotated[Optional[List[StrictStr]], Field(description="The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.")] = None,
    run_output_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the runOutputTags are filtered. ")] = None,
    connector_tag: Annotated[Optional[List[StrictStr]], Field(description="The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.")] = None,
    connector_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the connectorTags are filtered. ")] = None,
    technical_tag: Annotated[Optional[List[StrictStr]], Field(description="The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.")] = None,
    technical_tag_match_mode: Annotated[Optional[StrictStr], Field(description="How the technicalTags are filtered. ")] = None,
    not_in_run: Annotated[Optional[StrictBool], Field(description="When set to true, the data will be filtered on data which is not used in a run.")] = None,
    instrument_run_id: Annotated[Optional[List[StrictStr]], Field(description="The instrument run IDs of the sequencing runs to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the list of sample data.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample to retrieve data for (required)
    :type sample_id: str
    :param full_text: To search through multiple fields of data.
    :type full_text: str
    :param id: The ids to filter on. This will always match exact.
    :type id: List[str]
    :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done.
    :type filename: List[str]
    :param filename_match_mode: How the filenames are filtered. 
    :type filename_match_mode: str
    :param file_path: The paths of the files to filter on.
    :type file_path: List[str]
    :param file_path_match_mode: How the file paths are filtered:   - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively).  - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt).
    :type file_path_match_mode: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param format_id: The IDs of the formats to filter on.
    :type format_id: List[str]
    :param format_code: The codes of the formats to filter on.
    :type format_code: List[str]
    :param type: The type to filter on.
    :type type: str
    :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively.
    :type parent_folder_id: List[str]
    :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files.
    :type parent_folder_path: str
    :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_after: datetime
    :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type creation_date_before: datetime
    :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_after: datetime
    :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z
    :type status_date_before: datetime
    :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done.
    :type user_tag: List[str]
    :param user_tag_match_mode: How the usertags are filtered. 
    :type user_tag_match_mode: str
    :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done.
    :type run_input_tag: List[str]
    :param run_input_tag_match_mode: How the runInputTags are filtered. 
    :type run_input_tag_match_mode: str
    :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done.
    :type run_output_tag: List[str]
    :param run_output_tag_match_mode: How the runOutputTags are filtered. 
    :type run_output_tag_match_mode: str
    :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done.
    :type connector_tag: List[str]
    :param connector_tag_match_mode: How the connectorTags are filtered. 
    :type connector_tag_match_mode: str
    :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done.
    :type technical_tag: List[str]
    :param technical_tag_match_mode: How the technicalTags are filtered. 
    :type technical_tag_match_mode: str
    :param not_in_run: When set to true, the data will be filtered on data which is not used in a run.
    :type not_in_run: bool
    :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on.
    :type instrument_run_id: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_data_list_serialize(
        project_id=project_id,
        sample_id=sample_id,
        full_text=full_text,
        id=id,
        filename=filename,
        filename_match_mode=filename_match_mode,
        file_path=file_path,
        file_path_match_mode=file_path_match_mode,
        status=status,
        format_id=format_id,
        format_code=format_code,
        type=type,
        parent_folder_id=parent_folder_id,
        parent_folder_path=parent_folder_path,
        creation_date_after=creation_date_after,
        creation_date_before=creation_date_before,
        status_date_after=status_date_after,
        status_date_before=status_date_before,
        user_tag=user_tag,
        user_tag_match_mode=user_tag_match_mode,
        run_input_tag=run_input_tag,
        run_input_tag_match_mode=run_input_tag_match_mode,
        run_output_tag=run_output_tag,
        run_output_tag_match_mode=run_output_tag_match_mode,
        connector_tag=connector_tag,
        connector_tag_match_mode=connector_tag_match_mode,
        technical_tag=technical_tag,
        technical_tag_match_mode=technical_tag_match_mode,
        not_in_run=not_in_run,
        instrument_run_id=instrument_run_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "DataPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the list of sample data.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample to retrieve data for (required) :type sample_id: str :param full_text: To search through multiple fields of data. :type full_text: str :param id: The ids to filter on. This will always match exact. :type id: List[str] :param filename: The filenames to filter on. The filenameMatchMode-parameter determines how the filtering is done. :type filename: List[str] :param filename_match_mode: How the filenames are filtered. :type filename_match_mode: str :param file_path: The paths of the files to filter on. :type file_path: List[str] :param file_path_match_mode: How the file paths are filtered: - STARTS_WITH_CASE_INSENSITIVE: Filters the file path to start with the value of the 'filePath' parameter, regardless of upper/lower casing. This allows e.g. listing all data in a folder and all it's sub-folders (recursively). - FULL_CASE_INSENSITIVE: Filters the file path to fully match the value of the 'filePath' parameter, regardless of upper/lower casing. Note that this can result in multiple results if e.g. two files exist with the same filename but different casing (abc.txt and ABC.txt). :type file_path_match_mode: str :param status: The statuses to filter on. :type status: List[str] :param format_id: The IDs of the formats to filter on. :type format_id: List[str] :param format_code: The codes of the formats to filter on. :type format_code: List[str] :param type: The type to filter on. :type type: str :param parent_folder_id: The IDs of parents folders to filter on. Lists all files and folders within the folder for the given ID, non-recursively. :type parent_folder_id: List[str] :param parent_folder_path: The full path of the parent folder. Should start and end with a '/'. Lists all files and folders within the folder for the given path, non-recursively. This can be used to browse through the hierarchical tree of folders, e.g. traversing one level up can be done by removing the last part of the path. This does not work for contents from a linked folder apposed to individual linked files. :type parent_folder_path: str :param creation_date_after: The date after which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_after: datetime :param creation_date_before: The date before which the data is created. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type creation_date_before: datetime :param status_date_after: The date after which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_after: datetime :param status_date_before: The date before which the status has been updated. Format: yyyy-MM-dd'T'HH:mm:ss'Z' eg: 2021-01-30T08:30:00Z :type status_date_before: datetime :param user_tag: The usertags to filter on. The userTagMatchMode-parameter determines how the filtering is done. :type user_tag: List[str] :param user_tag_match_mode: How the usertags are filtered. :type user_tag_match_mode: str :param run_input_tag: The runInputTags to filter on. The runInputTagMatchMode-parameter determines how the filtering is done. :type run_input_tag: List[str] :param run_input_tag_match_mode: How the runInputTags are filtered. :type run_input_tag_match_mode: str :param run_output_tag: The runOutputTags to filter on. The runOutputTagMatchMode-parameter determines how the filtering is done. :type run_output_tag: List[str] :param run_output_tag_match_mode: How the runOutputTags are filtered. :type run_output_tag_match_mode: str :param connector_tag: The connectorTags to filter on. The connectorTagMatchMode-parameter determines how the filtering is done. :type connector_tag: List[str] :param connector_tag_match_mode: How the connectorTags are filtered. :type connector_tag_match_mode: str :param technical_tag: The technicalTags to filter on. The techTagMatchMode-parameter determines how the filtering is done. :type technical_tag: List[str] :param technical_tag_match_mode: How the technicalTags are filtered. :type technical_tag_match_mode: str :param not_in_run: When set to true, the data will be filtered on data which is not used in a run. :type not_in_run: bool :param instrument_run_id: The instrument run IDs of the sequencing runs to filter on. :type instrument_run_id: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - path - fileSizeInBytes - status - format - dataType - willBeArchivedAt - willBeDeletedAt :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_history(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> SampleHistoryList

Expand source code

@validate_call
def get_sample_history(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> SampleHistoryList:
    """Retrieve sample history.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_history_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleHistoryList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve sample history.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_history_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> ApiResponse[SampleHistoryList]

Expand source code

@validate_call
def get_sample_history_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[SampleHistoryList]:
    """Retrieve sample history.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_history_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleHistoryList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve sample history.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_history_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_sample_history_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve sample history.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_history_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleHistoryList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve sample history.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_metadata_field(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
field_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the field')]) ‑> ModelField

Expand source code

@validate_call
def get_sample_metadata_field(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    field_id: Annotated[StrictStr, Field(description="The ID of the field")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ModelField:
    """Retrieve a metadata field.

    Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param field_id: The ID of the field (required)
    :type field_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_metadata_field_serialize(
        project_id=project_id,
        sample_id=sample_id,
        field_id=field_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ModelField",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a metadata field.

Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param field_id: The ID of the field (required) :type field_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_metadata_field_count(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
field_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the field')]) ‑> ModelField

Expand source code

@validate_call
def get_sample_metadata_field_count(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    field_id: Annotated[StrictStr, Field(description="The ID of the field")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ModelField:
    """Retrieves the number of occurrences of a given field.

    Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param field_id: The ID of the field (required)
    :type field_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_metadata_field_count_serialize(
        project_id=project_id,
        sample_id=sample_id,
        field_id=field_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ModelField",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieves the number of occurrences of a given field.

Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param field_id: The ID of the field (required) :type field_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_metadata_field_count_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
field_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the field')]) ‑> ApiResponse[ModelField]

Expand source code

@validate_call
def get_sample_metadata_field_count_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    field_id: Annotated[StrictStr, Field(description="The ID of the field")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ModelField]:
    """Retrieves the number of occurrences of a given field.

    Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param field_id: The ID of the field (required)
    :type field_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_metadata_field_count_serialize(
        project_id=project_id,
        sample_id=sample_id,
        field_id=field_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ModelField",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieves the number of occurrences of a given field.

Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param field_id: The ID of the field (required) :type field_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_metadata_field_count_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
field_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the field')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_sample_metadata_field_count_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    field_id: Annotated[StrictStr, Field(description="The ID of the field")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieves the number of occurrences of a given field.

    Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param field_id: The ID of the field (required)
    :type field_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_metadata_field_count_serialize(
        project_id=project_id,
        sample_id=sample_id,
        field_id=field_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ModelField",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieves the number of occurrences of a given field.

Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param field_id: The ID of the field (required) :type field_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_metadata_field_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
field_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the field')]) ‑> ApiResponse[ModelField]

Expand source code

@validate_call
def get_sample_metadata_field_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    field_id: Annotated[StrictStr, Field(description="The ID of the field")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ModelField]:
    """Retrieve a metadata field.

    Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param field_id: The ID of the field (required)
    :type field_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_metadata_field_serialize(
        project_id=project_id,
        sample_id=sample_id,
        field_id=field_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ModelField",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a metadata field.

Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param field_id: The ID of the field (required) :type field_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_metadata_field_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
field_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the field')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_sample_metadata_field_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    field_id: Annotated[StrictStr, Field(description="The ID of the field")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a metadata field.

    Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param field_id: The ID of the field (required)
    :type field_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_metadata_field_serialize(
        project_id=project_id,
        sample_id=sample_id,
        field_id=field_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ModelField",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a metadata field.

Returns a list of values for the field with identifier fieldId belonging to the sample with identifier sampleId. If the field is a group field that can occur more than once or belongs to a group field that can occur more than once the return value will have one entry in the list for each occurrence. If not the return value will be a single value list

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param field_id: The ID of the field (required) :type field_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_data_to_sample(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
data_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the data to link')]) ‑> None

Expand source code

@validate_call
def link_data_to_sample(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    data_id: Annotated[StrictStr, Field(description="The ID of the data to link")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Link data to a sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param data_id: The ID of the data to link (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_data_to_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Link data to a sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param data_id: The ID of the data to link (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_data_to_sample_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
data_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the data to link')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def link_data_to_sample_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    data_id: Annotated[StrictStr, Field(description="The ID of the data to link")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Link data to a sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param data_id: The ID of the data to link (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_data_to_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Link data to a sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param data_id: The ID of the data to link (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_data_to_sample_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
data_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the data to link')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def link_data_to_sample_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    data_id: Annotated[StrictStr, Field(description="The ID of the data to link")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Link data to a sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param data_id: The ID of the data to link (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_data_to_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Link data to a sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param data_id: The ID of the data to link (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_sample_to_project(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> ProjectSample

Expand source code

@validate_call
def link_sample_to_project(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectSample:
    """Link a sample to a project.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_sample_to_project_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Link a sample to a project.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_sample_to_project_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[ProjectSample]

Expand source code

@validate_call
def link_sample_to_project_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectSample]:
    """Link a sample to a project.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_sample_to_project_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Link a sample to a project.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def link_sample_to_project_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def link_sample_to_project_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Link a sample to a project.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._link_sample_to_project_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Link a sample to a project.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def mark_sample_deleted(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> None

Expand source code

@validate_call
def mark_sample_deleted(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Mark a sample deleted.

    Endpoint for marking a sample as deleted.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._mark_sample_deleted_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Mark a sample deleted.

Endpoint for marking a sample as deleted.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def mark_sample_deleted_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def mark_sample_deleted_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Mark a sample deleted.

    Endpoint for marking a sample as deleted.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._mark_sample_deleted_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Mark a sample deleted.

Endpoint for marking a sample as deleted.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def mark_sample_deleted_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def mark_sample_deleted_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Mark a sample deleted.

    Endpoint for marking a sample as deleted.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._mark_sample_deleted_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Mark a sample deleted.

Endpoint for marking a sample as deleted.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_project_sample_analyses(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> AnalysisPagedListV4

Expand source code

@validate_call
def search_project_sample_analyses(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> AnalysisPagedListV4:
    """Search analyses for sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_project_sample_analyses_serialize(
        project_id=project_id,
        sample_id=sample_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Search analyses for sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_project_sample_analyses_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> ApiResponse[AnalysisPagedListV4]

Expand source code

@validate_call
def search_project_sample_analyses_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[AnalysisPagedListV4]:
    """Search analyses for sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_project_sample_analyses_serialize(
        project_id=project_id,
        sample_id=sample_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Search analyses for sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_project_sample_analyses_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def search_project_sample_analyses_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Search analyses for sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_project_sample_analyses_serialize(
        project_id=project_id,
        sample_id=sample_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "AnalysisPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Search analyses for sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_data_from_sample(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
data_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the data to unlink')]) ‑> None

Expand source code

@validate_call
def unlink_data_from_sample(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    data_id: Annotated[StrictStr, Field(description="The ID of the data to unlink")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Unlink data from a sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param data_id: The ID of the data to unlink (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_data_from_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Unlink data from a sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param data_id: The ID of the data to unlink (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_data_from_sample_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
data_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the data to unlink')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unlink_data_from_sample_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    data_id: Annotated[StrictStr, Field(description="The ID of the data to unlink")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Unlink data from a sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param data_id: The ID of the data to unlink (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_data_from_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Unlink data from a sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param data_id: The ID of the data to unlink (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_data_from_sample_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample')],
data_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the data to unlink')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unlink_data_from_sample_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: Annotated[StrictStr, Field(description="The ID of the sample")],
    data_id: Annotated[StrictStr, Field(description="The ID of the data to unlink")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Unlink data from a sample.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: The ID of the sample (required)
    :type sample_id: str
    :param data_id: The ID of the data to unlink (required)
    :type data_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_data_from_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        data_id=data_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Unlink data from a sample.

:param project_id: (required) :type project_id: str :param sample_id: The ID of the sample (required) :type sample_id: str :param data_id: The ID of the data to unlink (required) :type data_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_sample_from_project(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def unlink_sample_from_project(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Unlink a sample from a project.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_sample_from_project_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Unlink a sample from a project.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_sample_from_project_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def unlink_sample_from_project_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Unlink a sample from a project.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_sample_from_project_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Unlink a sample from a project.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def unlink_sample_from_project_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def unlink_sample_from_project_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Unlink a sample from a project.


    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._unlink_sample_from_project_serialize(
        project_id=project_id,
        sample_id=sample_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Unlink a sample from a project.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_sample(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)],
project_sample: ProjectSample,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ProjectSample

Expand source code

@validate_call
def update_project_sample(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    project_sample: ProjectSample,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ProjectSample:
    """Update a project sample.

    Fields which can be updated: - sample.name - sample.description - sample.status - sample.tags

    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param project_sample: (required)
    :type project_sample: ProjectSample
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        project_sample=project_sample,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update a project sample.

Fields which can be updated: - sample.name - sample.description - sample.status - sample.tags

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param project_sample: (required) :type project_sample: ProjectSample :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_sample_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)],
project_sample: ProjectSample,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[ProjectSample]

Expand source code

@validate_call
def update_project_sample_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    project_sample: ProjectSample,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ProjectSample]:
    """Update a project sample.

    Fields which can be updated: - sample.name - sample.description - sample.status - sample.tags

    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param project_sample: (required)
    :type project_sample: ProjectSample
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        project_sample=project_sample,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update a project sample.

Fields which can be updated: - sample.name - sample.description - sample.status - sample.tags

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param project_sample: (required) :type project_sample: ProjectSample :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_project_sample_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)],
project_sample: ProjectSample,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_project_sample_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    project_sample: ProjectSample,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update a project sample.

    Fields which can be updated: - sample.name - sample.description - sample.status - sample.tags

    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param project_sample: (required)
    :type project_sample: ProjectSample
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_project_sample_serialize(
        project_id=project_id,
        sample_id=sample_id,
        project_sample=project_sample,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ProjectSample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update a project sample.

Fields which can be updated: - sample.name - sample.description - sample.status - sample.tags

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param project_sample: (required) :type project_sample: ProjectSample :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_sample_metadata_fields(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)],
update_metadata: UpdateMetadata) ‑> Sample

Expand source code

@validate_call
def update_sample_metadata_fields(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    update_metadata: UpdateMetadata,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Sample:
    """Update metadata fields.

    Endpoint for updating metadata fields.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param update_metadata: (required)
    :type update_metadata: UpdateMetadata
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_sample_metadata_fields_serialize(
        project_id=project_id,
        sample_id=sample_id,
        update_metadata=update_metadata,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': "Sample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update metadata fields.

Endpoint for updating metadata fields.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param update_metadata: (required) :type update_metadata: UpdateMetadata :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_sample_metadata_fields_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)],
update_metadata: UpdateMetadata) ‑> ApiResponse[Sample]

Expand source code

@validate_call
def update_sample_metadata_fields_with_http_info(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    update_metadata: UpdateMetadata,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Sample]:
    """Update metadata fields.

    Endpoint for updating metadata fields.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param update_metadata: (required)
    :type update_metadata: UpdateMetadata
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_sample_metadata_fields_serialize(
        project_id=project_id,
        sample_id=sample_id,
        update_metadata=update_metadata,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': "Sample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update metadata fields.

Endpoint for updating metadata fields.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param update_metadata: (required) :type update_metadata: UpdateMetadata :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_sample_metadata_fields_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
sample_id: Annotated[str, Strict(strict=True)],
update_metadata: UpdateMetadata) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_sample_metadata_fields_without_preload_content(
    self,
    project_id: StrictStr,
    sample_id: StrictStr,
    update_metadata: UpdateMetadata,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update metadata fields.

    Endpoint for updating metadata fields.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param project_id: (required)
    :type project_id: str
    :param sample_id: (required)
    :type sample_id: str
    :param update_metadata: (required)
    :type update_metadata: UpdateMetadata
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_sample_metadata_fields_serialize(
        project_id=project_id,
        sample_id=sample_id,
        update_metadata=update_metadata,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': "Sample",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update metadata fields.

Endpoint for updating metadata fields.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param project_id: (required) :type project_id: str :param sample_id: (required) :type sample_id: str :param update_metadata: (required) :type update_metadata: UpdateMetadata :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectSampleBatchApi (api_client=None)

Expand source code

class ProjectSampleBatchApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_sample_creation_batch(
        self,
        project_id: StrictStr,
        create_sample_creation_batch: CreateSampleCreationBatch,
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> SampleCreationBatch:
        """Create a sample creation batch.


        :param project_id: (required)
        :type project_id: str
        :param create_sample_creation_batch: (required)
        :type create_sample_creation_batch: CreateSampleCreationBatch
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_sample_creation_batch_serialize(
            project_id=project_id,
            create_sample_creation_batch=create_sample_creation_batch,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "SampleCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_sample_creation_batch_with_http_info(
        self,
        project_id: StrictStr,
        create_sample_creation_batch: CreateSampleCreationBatch,
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[SampleCreationBatch]:
        """Create a sample creation batch.


        :param project_id: (required)
        :type project_id: str
        :param create_sample_creation_batch: (required)
        :type create_sample_creation_batch: CreateSampleCreationBatch
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_sample_creation_batch_serialize(
            project_id=project_id,
            create_sample_creation_batch=create_sample_creation_batch,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "SampleCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_sample_creation_batch_without_preload_content(
        self,
        project_id: StrictStr,
        create_sample_creation_batch: CreateSampleCreationBatch,
        idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a sample creation batch.


        :param project_id: (required)
        :type project_id: str
        :param create_sample_creation_batch: (required)
        :type create_sample_creation_batch: CreateSampleCreationBatch
        :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
        :type idempotency_key: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_sample_creation_batch_serialize(
            project_id=project_id,
            create_sample_creation_batch=create_sample_creation_batch,
            idempotency_key=idempotency_key,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "SampleCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_sample_creation_batch_serialize(
        self,
        project_id,
        create_sample_creation_batch,
        idempotency_key,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        # process the header parameters
        if idempotency_key is not None:
            _header_params['Idempotency-Key'] = idempotency_key
        # process the form parameters
        # process the body parameter
        if create_sample_creation_batch is not None:
            _body_params = create_sample_creation_batch


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/x-www-form-urlencoded', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/sampleCreationBatch',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_sample_creation_batch(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> SampleCreationBatch:
        """Retrieve a sample creation batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the sample creation batch (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_creation_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_sample_creation_batch_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[SampleCreationBatch]:
        """Retrieve a sample creation batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the sample creation batch (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_creation_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_sample_creation_batch_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a sample creation batch.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the sample creation batch (required)
        :type batch_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_creation_batch_serialize(
            project_id=project_id,
            batch_id=batch_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleCreationBatch",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_sample_creation_batch_serialize(
        self,
        project_id,
        batch_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/sampleCreationBatch/{batchId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_sample_creation_batch_item(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
        item_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch item")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> SampleCreationBatchSampleItem:
        """Retrieve a sample creation batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the sample creation batch (required)
        :type batch_id: str
        :param item_id: The ID of the sample creation batch item (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_creation_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleCreationBatchSampleItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_sample_creation_batch_item_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
        item_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch item")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[SampleCreationBatchSampleItem]:
        """Retrieve a sample creation batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the sample creation batch (required)
        :type batch_id: str
        :param item_id: The ID of the sample creation batch item (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_creation_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleCreationBatchSampleItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_sample_creation_batch_item_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
        item_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch item")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a sample creation batch item.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the sample creation batch (required)
        :type batch_id: str
        :param item_id: The ID of the sample creation batch item (required)
        :type item_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_creation_batch_item_serialize(
            project_id=project_id,
            batch_id=batch_id,
            item_id=item_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleCreationBatchSampleItem",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_sample_creation_batch_item_serialize(
        self,
        project_id,
        batch_id,
        item_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        if item_id is not None:
            _path_params['itemId'] = item_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/sampleCreationBatch/{batchId}/items/{itemId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_sample_creation_batch_items(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> SampleCreationBatchItemPagedList:
        """Retrieve a list of sample creation batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the sample creation batch (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_creation_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleCreationBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_sample_creation_batch_items_with_http_info(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[SampleCreationBatchItemPagedList]:
        """Retrieve a list of sample creation batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the sample creation batch (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_creation_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleCreationBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_sample_creation_batch_items_without_preload_content(
        self,
        project_id: StrictStr,
        batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
        status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of sample creation batch items.


        :param project_id: (required)
        :type project_id: str
        :param batch_id: The ID of the sample creation batch (required)
        :type batch_id: str
        :param status: The statuses to filter on.
        :type status: List[str]
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sample_creation_batch_items_serialize(
            project_id=project_id,
            batch_id=batch_id,
            status=status,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SampleCreationBatchItemPagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_sample_creation_batch_items_serialize(
        self,
        project_id,
        batch_id,
        status,
        page_offset,
        page_token,
        page_size,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
            'status': 'multi',
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if batch_id is not None:
            _path_params['batchId'] = batch_id
        # process the query parameters
        if status is not None:
            
            _query_params.append(('status', status))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/sampleCreationBatch/{batchId}/items',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_sample_creation_batch(self,
project_id: Annotated[str, Strict(strict=True)],
create_sample_creation_batch: CreateSampleCreationBatch,
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> SampleCreationBatch

Expand source code

@validate_call
def create_sample_creation_batch(
    self,
    project_id: StrictStr,
    create_sample_creation_batch: CreateSampleCreationBatch,
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> SampleCreationBatch:
    """Create a sample creation batch.


    :param project_id: (required)
    :type project_id: str
    :param create_sample_creation_batch: (required)
    :type create_sample_creation_batch: CreateSampleCreationBatch
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_sample_creation_batch_serialize(
        project_id=project_id,
        create_sample_creation_batch=create_sample_creation_batch,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "SampleCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a sample creation batch.

:param project_id: (required) :type project_id: str :param create_sample_creation_batch: (required) :type create_sample_creation_batch: CreateSampleCreationBatch :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_sample_creation_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
create_sample_creation_batch: CreateSampleCreationBatch,
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> ApiResponse[SampleCreationBatch]

Expand source code

@validate_call
def create_sample_creation_batch_with_http_info(
    self,
    project_id: StrictStr,
    create_sample_creation_batch: CreateSampleCreationBatch,
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[SampleCreationBatch]:
    """Create a sample creation batch.


    :param project_id: (required)
    :type project_id: str
    :param create_sample_creation_batch: (required)
    :type create_sample_creation_batch: CreateSampleCreationBatch
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_sample_creation_batch_serialize(
        project_id=project_id,
        create_sample_creation_batch=create_sample_creation_batch,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "SampleCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a sample creation batch.

:param project_id: (required) :type project_id: str :param create_sample_creation_batch: (required) :type create_sample_creation_batch: CreateSampleCreationBatch :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_sample_creation_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
create_sample_creation_batch: CreateSampleCreationBatch,
idempotency_key: Annotated[Annotated[str, FieldInfo(annotation=NoneType, required=True, metadata=[Strict(strict=True), MaxLen(max_length=255)])] | None, FieldInfo(annotation=NoneType, required=True, description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_sample_creation_batch_without_preload_content(
    self,
    project_id: StrictStr,
    create_sample_creation_batch: CreateSampleCreationBatch,
    idempotency_key: Annotated[Optional[Annotated[str, Field(strict=True, max_length=255)]], Field(description="The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a sample creation batch.


    :param project_id: (required)
    :type project_id: str
    :param create_sample_creation_batch: (required)
    :type create_sample_creation_batch: CreateSampleCreationBatch
    :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response  will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes  a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:<br /><ul><li>the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.</li><li>the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.</li><li>the request body is not the same as the previous request => 422 error response, as this is not allowed.</li></ul>This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification.
    :type idempotency_key: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_sample_creation_batch_serialize(
        project_id=project_id,
        create_sample_creation_batch=create_sample_creation_batch,
        idempotency_key=idempotency_key,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "SampleCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a sample creation batch.

:param project_id: (required) :type project_id: str :param create_sample_creation_batch: (required) :type create_sample_creation_batch: CreateSampleCreationBatch :param idempotency_key: The Idempotency-Key header can be used to prevent duplicate requests and support retries. It is implemented according to the IETF spec, with one exception (see below). The header value is allowed to be max 255 characters long. If the header is supplied for a successful response (HTTP status code < 400) then the response will be saved for 7 days for the specific API endpoint, header value and user reference. When the same user makes a new request within 7 days to the same API endpoint with the same Idempotency-Key header value, following use cases can occur:

• the request body is the same as the previous request and an answer is stored => the stored response is returned without executing the request again.
• the request body is the same as the previous request and no answer is stored because the previous request has not finished => 409 error response, which indicates that the original call is still in progress.
• the request body is not the same as the previous request => 422 error response, as this is not allowed.

This means that each time when executing a new API request using the Idempotency-Key header, the request has to contain a new header value that hasn't been used (successfully) in the past 7 days for that specific API endpoint and by the specific user. For error responses (HTTP status code >= 400) we allow clients to retry the call. This is where we don't follow the IETF specification. :type idempotency_key: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_creation_batch(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch')]) ‑> SampleCreationBatch

Expand source code

@validate_call
def get_sample_creation_batch(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> SampleCreationBatch:
    """Retrieve a sample creation batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the sample creation batch (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_creation_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a sample creation batch.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the sample creation batch (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_creation_batch_item(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch')],
item_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch item')]) ‑> SampleCreationBatchSampleItem

Expand source code

@validate_call
def get_sample_creation_batch_item(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
    item_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch item")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> SampleCreationBatchSampleItem:
    """Retrieve a sample creation batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the sample creation batch (required)
    :type batch_id: str
    :param item_id: The ID of the sample creation batch item (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_creation_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleCreationBatchSampleItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a sample creation batch item.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the sample creation batch (required) :type batch_id: str :param item_id: The ID of the sample creation batch item (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_creation_batch_item_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch')],
item_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch item')]) ‑> ApiResponse[SampleCreationBatchSampleItem]

Expand source code

@validate_call
def get_sample_creation_batch_item_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
    item_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch item")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[SampleCreationBatchSampleItem]:
    """Retrieve a sample creation batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the sample creation batch (required)
    :type batch_id: str
    :param item_id: The ID of the sample creation batch item (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_creation_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleCreationBatchSampleItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a sample creation batch item.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the sample creation batch (required) :type batch_id: str :param item_id: The ID of the sample creation batch item (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_creation_batch_item_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch')],
item_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch item')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_sample_creation_batch_item_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
    item_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch item")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a sample creation batch item.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the sample creation batch (required)
    :type batch_id: str
    :param item_id: The ID of the sample creation batch item (required)
    :type item_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_creation_batch_item_serialize(
        project_id=project_id,
        batch_id=batch_id,
        item_id=item_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleCreationBatchSampleItem",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a sample creation batch item.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the sample creation batch (required) :type batch_id: str :param item_id: The ID of the sample creation batch item (required) :type item_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_creation_batch_items(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch')],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> SampleCreationBatchItemPagedList

Expand source code

@validate_call
def get_sample_creation_batch_items(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> SampleCreationBatchItemPagedList:
    """Retrieve a list of sample creation batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the sample creation batch (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_creation_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleCreationBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of sample creation batch items.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the sample creation batch (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_creation_batch_items_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch')],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> ApiResponse[SampleCreationBatchItemPagedList]

Expand source code

@validate_call
def get_sample_creation_batch_items_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[SampleCreationBatchItemPagedList]:
    """Retrieve a list of sample creation batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the sample creation batch (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_creation_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleCreationBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of sample creation batch items.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the sample creation batch (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_creation_batch_items_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch')],
status: Annotated[List[Annotated[str, Strict(strict=True)]] | None, FieldInfo(annotation=NoneType, required=True, description='The statuses to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_sample_creation_batch_items_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
    status: Annotated[Optional[List[StrictStr]], Field(description="The statuses to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of sample creation batch items.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the sample creation batch (required)
    :type batch_id: str
    :param status: The statuses to filter on.
    :type status: List[str]
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_creation_batch_items_serialize(
        project_id=project_id,
        batch_id=batch_id,
        status=status,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleCreationBatchItemPagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of sample creation batch items.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the sample creation batch (required) :type batch_id: str :param status: The statuses to filter on. :type status: List[str] :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_creation_batch_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch')]) ‑> ApiResponse[SampleCreationBatch]

Expand source code

@validate_call
def get_sample_creation_batch_with_http_info(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[SampleCreationBatch]:
    """Retrieve a sample creation batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the sample creation batch (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_creation_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a sample creation batch.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the sample creation batch (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sample_creation_batch_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
batch_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sample creation batch')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_sample_creation_batch_without_preload_content(
    self,
    project_id: StrictStr,
    batch_id: Annotated[StrictStr, Field(description="The ID of the sample creation batch")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a sample creation batch.


    :param project_id: (required)
    :type project_id: str
    :param batch_id: The ID of the sample creation batch (required)
    :type batch_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sample_creation_batch_serialize(
        project_id=project_id,
        batch_id=batch_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SampleCreationBatch",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a sample creation batch.

:param project_id: (required) :type project_id: str :param batch_id: The ID of the sample creation batch (required) :type batch_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ProjectSamplePagedList (**data: Any)

Expand source code

class ProjectSamplePagedList(BaseModel):
    """
    ProjectSamplePagedList
    """ # noqa: E501
    items: List[ProjectSample]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectSamplePagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectSamplePagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ProjectSample.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

ProjectSamplePagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ProjectSample]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectSamplePagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectSamplePagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectTag (**data: Any)

Expand source code

class ProjectTag(BaseModel):
    """
    ProjectTag
    """ # noqa: E501
    technical_tags: List[StrictStr] = Field(alias="technicalTags")
    user_tags: List[StrictStr] = Field(alias="userTags")
    __properties: ClassVar[List[str]] = ["technicalTags", "userTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ProjectTag from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ProjectTag from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "technicalTags": obj.get("technicalTags"),
            "userTags": obj.get("userTags")
        })
        return _obj

ProjectTag

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var technical_tags : List[str]

The type of the None singleton.

var user_tags : List[str]

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ProjectTag from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ProjectTag from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ProjectWorkflowSessionApi (api_client=None)

Expand source code

class ProjectWorkflowSessionApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_workflow_session_configurations(
        self,
        project_id: StrictStr,
        workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the configuration for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> WorkflowSessionConfigurationList:
        """Retrieve the configurations of a workflow session.


        :param project_id: (required)
        :type project_id: str
        :param workflow_session_id: The ID of the workflow session to retrieve the configuration for (required)
        :type workflow_session_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workflow_session_configurations_serialize(
            project_id=project_id,
            workflow_session_id=workflow_session_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionConfigurationList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_workflow_session_configurations_with_http_info(
        self,
        project_id: StrictStr,
        workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the configuration for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[WorkflowSessionConfigurationList]:
        """Retrieve the configurations of a workflow session.


        :param project_id: (required)
        :type project_id: str
        :param workflow_session_id: The ID of the workflow session to retrieve the configuration for (required)
        :type workflow_session_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workflow_session_configurations_serialize(
            project_id=project_id,
            workflow_session_id=workflow_session_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionConfigurationList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_workflow_session_configurations_without_preload_content(
        self,
        project_id: StrictStr,
        workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the configuration for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the configurations of a workflow session.


        :param project_id: (required)
        :type project_id: str
        :param workflow_session_id: The ID of the workflow session to retrieve the configuration for (required)
        :type workflow_session_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workflow_session_configurations_serialize(
            project_id=project_id,
            workflow_session_id=workflow_session_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionConfigurationList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_workflow_session_configurations_serialize(
        self,
        project_id,
        workflow_session_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if workflow_session_id is not None:
            _path_params['workflowSessionId'] = workflow_session_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/workflowSessions/{workflowSessionId}/configurations',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_workflow_session_inputs(
        self,
        project_id: StrictStr,
        workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the inputs for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> WorkflowSessionInputList:
        """Retrieve the inputs of a workflow session.


        :param project_id: (required)
        :type project_id: str
        :param workflow_session_id: The ID of the workflow session to retrieve the inputs for (required)
        :type workflow_session_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workflow_session_inputs_serialize(
            project_id=project_id,
            workflow_session_id=workflow_session_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionInputList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_workflow_session_inputs_with_http_info(
        self,
        project_id: StrictStr,
        workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the inputs for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[WorkflowSessionInputList]:
        """Retrieve the inputs of a workflow session.


        :param project_id: (required)
        :type project_id: str
        :param workflow_session_id: The ID of the workflow session to retrieve the inputs for (required)
        :type workflow_session_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workflow_session_inputs_serialize(
            project_id=project_id,
            workflow_session_id=workflow_session_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionInputList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_workflow_session_inputs_without_preload_content(
        self,
        project_id: StrictStr,
        workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the inputs for")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve the inputs of a workflow session.


        :param project_id: (required)
        :type project_id: str
        :param workflow_session_id: The ID of the workflow session to retrieve the inputs for (required)
        :type workflow_session_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workflow_session_inputs_serialize(
            project_id=project_id,
            workflow_session_id=workflow_session_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionInputList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_workflow_session_inputs_serialize(
        self,
        project_id,
        workflow_session_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if workflow_session_id is not None:
            _path_params['workflowSessionId'] = workflow_session_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/workflowSessions/{workflowSessionId}/inputs',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_workflow_sessions(
        self,
        project_id: StrictStr,
        reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
        userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
        technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> WorkflowSessionPagedListV3:
        """(Deprecated) Retrieve the list of workflow sessions.

        This endpoint only returns V3 items. Use the search endpoint to get V4 items.

        :param project_id: (required)
        :type project_id: str
        :param reference: The reference to filter on.
        :type reference: str
        :param userreference: The user-reference to filter on.
        :type userreference: str
        :param status: The status to filter on.
        :type status: str
        :param usertag: The user-tags to filter on.
        :type usertag: str
        :param technicaltag: The technical-tags to filter on.
        :type technicaltag: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/workflowSessions is deprecated.", DeprecationWarning)

        _param = self._get_workflow_sessions_serialize(
            project_id=project_id,
            reference=reference,
            userreference=userreference,
            status=status,
            usertag=usertag,
            technicaltag=technicaltag,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionPagedListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_workflow_sessions_with_http_info(
        self,
        project_id: StrictStr,
        reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
        userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
        technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[WorkflowSessionPagedListV3]:
        """(Deprecated) Retrieve the list of workflow sessions.

        This endpoint only returns V3 items. Use the search endpoint to get V4 items.

        :param project_id: (required)
        :type project_id: str
        :param reference: The reference to filter on.
        :type reference: str
        :param userreference: The user-reference to filter on.
        :type userreference: str
        :param status: The status to filter on.
        :type status: str
        :param usertag: The user-tags to filter on.
        :type usertag: str
        :param technicaltag: The technical-tags to filter on.
        :type technicaltag: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/workflowSessions is deprecated.", DeprecationWarning)

        _param = self._get_workflow_sessions_serialize(
            project_id=project_id,
            reference=reference,
            userreference=userreference,
            status=status,
            usertag=usertag,
            technicaltag=technicaltag,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionPagedListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_workflow_sessions_without_preload_content(
        self,
        project_id: StrictStr,
        reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
        userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
        status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
        usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
        technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """(Deprecated) Retrieve the list of workflow sessions.

        This endpoint only returns V3 items. Use the search endpoint to get V4 items.

        :param project_id: (required)
        :type project_id: str
        :param reference: The reference to filter on.
        :type reference: str
        :param userreference: The user-reference to filter on.
        :type userreference: str
        :param status: The status to filter on.
        :type status: str
        :param usertag: The user-tags to filter on.
        :type usertag: str
        :param technicaltag: The technical-tags to filter on.
        :type technicaltag: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501
        warnings.warn("GET /api/projects/{projectId}/workflowSessions is deprecated.", DeprecationWarning)

        _param = self._get_workflow_sessions_serialize(
            project_id=project_id,
            reference=reference,
            userreference=userreference,
            status=status,
            usertag=usertag,
            technicaltag=technicaltag,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionPagedListV3",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_workflow_sessions_serialize(
        self,
        project_id,
        reference,
        userreference,
        status,
        usertag,
        technicaltag,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if reference is not None:
            
            _query_params.append(('reference', reference))
            
        if userreference is not None:
            
            _query_params.append(('userreference', userreference))
            
        if status is not None:
            
            _query_params.append(('status', status))
            
        if usertag is not None:
            
            _query_params.append(('usertag', usertag))
            
        if technicaltag is not None:
            
            _query_params.append(('technicaltag', technicaltag))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/projects/{projectId}/workflowSessions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def search_orchestrated_analyses(
        self,
        project_id: StrictStr,
        workflow_session_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> WorkflowSessionAnalysisPagedListV4:
        """Search analyses orchestrated by the workflow session.


        :param project_id: (required)
        :type project_id: str
        :param workflow_session_id: (required)
        :type workflow_session_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_orchestrated_analyses_serialize(
            project_id=project_id,
            workflow_session_id=workflow_session_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionAnalysisPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def search_orchestrated_analyses_with_http_info(
        self,
        project_id: StrictStr,
        workflow_session_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[WorkflowSessionAnalysisPagedListV4]:
        """Search analyses orchestrated by the workflow session.


        :param project_id: (required)
        :type project_id: str
        :param workflow_session_id: (required)
        :type workflow_session_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_orchestrated_analyses_serialize(
            project_id=project_id,
            workflow_session_id=workflow_session_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionAnalysisPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def search_orchestrated_analyses_without_preload_content(
        self,
        project_id: StrictStr,
        workflow_session_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Search analyses orchestrated by the workflow session.


        :param project_id: (required)
        :type project_id: str
        :param workflow_session_id: (required)
        :type workflow_session_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_orchestrated_analyses_serialize(
            project_id=project_id,
            workflow_session_id=workflow_session_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionAnalysisPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _search_orchestrated_analyses_serialize(
        self,
        project_id,
        workflow_session_id,
        page_offset,
        page_token,
        page_size,
        sort,
        analysis_query_parameters,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        if workflow_session_id is not None:
            _path_params['workflowSessionId'] = workflow_session_id
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if analysis_query_parameters is not None:
            _body_params = analysis_query_parameters


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/workflowSessions/{workflowSessionId}/analyses:search',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def search_workflow_sessions(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> WorkflowSessionPagedListV4:
        """Search workflow sessions.


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_workflow_sessions_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def search_workflow_sessions_with_http_info(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[WorkflowSessionPagedListV4]:
        """Search workflow sessions.


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_workflow_sessions_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def search_workflow_sessions_without_preload_content(
        self,
        project_id: StrictStr,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
        analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Search workflow sessions.


        :param project_id: (required)
        :type project_id: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
        :type sort: str
        :param analysis_query_parameters:
        :type analysis_query_parameters: AnalysisQueryParameters
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._search_workflow_sessions_serialize(
            project_id=project_id,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            analysis_query_parameters=analysis_query_parameters,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkflowSessionPagedListV4",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _search_workflow_sessions_serialize(
        self,
        project_id,
        page_offset,
        page_token,
        page_size,
        sort,
        analysis_query_parameters,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if project_id is not None:
            _path_params['projectId'] = project_id
        # process the query parameters
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if analysis_query_parameters is not None:
            _body_params = analysis_query_parameters


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/projects/{projectId}/workflowSessions:search',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_workflow_session_configurations(self,
project_id: Annotated[str, Strict(strict=True)],
workflow_session_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the workflow session to retrieve the libica.openapi.v3.configuration for')]) ‑> WorkflowSessionConfigurationList

Expand source code

@validate_call
def get_workflow_session_configurations(
    self,
    project_id: StrictStr,
    workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the configuration for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> WorkflowSessionConfigurationList:
    """Retrieve the configurations of a workflow session.


    :param project_id: (required)
    :type project_id: str
    :param workflow_session_id: The ID of the workflow session to retrieve the configuration for (required)
    :type workflow_session_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workflow_session_configurations_serialize(
        project_id=project_id,
        workflow_session_id=workflow_session_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionConfigurationList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the configurations of a workflow session.

:param project_id: (required) :type project_id: str :param workflow_session_id: The ID of the workflow session to retrieve the configuration for (required) :type workflow_session_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workflow_session_configurations_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
workflow_session_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the workflow session to retrieve the libica.openapi.v3.configuration for')]) ‑> ApiResponse[WorkflowSessionConfigurationList]

Expand source code

@validate_call
def get_workflow_session_configurations_with_http_info(
    self,
    project_id: StrictStr,
    workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the configuration for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[WorkflowSessionConfigurationList]:
    """Retrieve the configurations of a workflow session.


    :param project_id: (required)
    :type project_id: str
    :param workflow_session_id: The ID of the workflow session to retrieve the configuration for (required)
    :type workflow_session_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workflow_session_configurations_serialize(
        project_id=project_id,
        workflow_session_id=workflow_session_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionConfigurationList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the configurations of a workflow session.

:param project_id: (required) :type project_id: str :param workflow_session_id: The ID of the workflow session to retrieve the configuration for (required) :type workflow_session_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workflow_session_configurations_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
workflow_session_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the workflow session to retrieve the libica.openapi.v3.configuration for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_workflow_session_configurations_without_preload_content(
    self,
    project_id: StrictStr,
    workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the configuration for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the configurations of a workflow session.


    :param project_id: (required)
    :type project_id: str
    :param workflow_session_id: The ID of the workflow session to retrieve the configuration for (required)
    :type workflow_session_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workflow_session_configurations_serialize(
        project_id=project_id,
        workflow_session_id=workflow_session_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionConfigurationList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the configurations of a workflow session.

:param project_id: (required) :type project_id: str :param workflow_session_id: The ID of the workflow session to retrieve the configuration for (required) :type workflow_session_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workflow_session_inputs(self,
project_id: Annotated[str, Strict(strict=True)],
workflow_session_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the workflow session to retrieve the inputs for')]) ‑> WorkflowSessionInputList

Expand source code

@validate_call
def get_workflow_session_inputs(
    self,
    project_id: StrictStr,
    workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the inputs for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> WorkflowSessionInputList:
    """Retrieve the inputs of a workflow session.


    :param project_id: (required)
    :type project_id: str
    :param workflow_session_id: The ID of the workflow session to retrieve the inputs for (required)
    :type workflow_session_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workflow_session_inputs_serialize(
        project_id=project_id,
        workflow_session_id=workflow_session_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionInputList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve the inputs of a workflow session.

:param project_id: (required) :type project_id: str :param workflow_session_id: The ID of the workflow session to retrieve the inputs for (required) :type workflow_session_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workflow_session_inputs_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
workflow_session_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the workflow session to retrieve the inputs for')]) ‑> ApiResponse[WorkflowSessionInputList]

Expand source code

@validate_call
def get_workflow_session_inputs_with_http_info(
    self,
    project_id: StrictStr,
    workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the inputs for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[WorkflowSessionInputList]:
    """Retrieve the inputs of a workflow session.


    :param project_id: (required)
    :type project_id: str
    :param workflow_session_id: The ID of the workflow session to retrieve the inputs for (required)
    :type workflow_session_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workflow_session_inputs_serialize(
        project_id=project_id,
        workflow_session_id=workflow_session_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionInputList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve the inputs of a workflow session.

:param project_id: (required) :type project_id: str :param workflow_session_id: The ID of the workflow session to retrieve the inputs for (required) :type workflow_session_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workflow_session_inputs_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
workflow_session_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the workflow session to retrieve the inputs for')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_workflow_session_inputs_without_preload_content(
    self,
    project_id: StrictStr,
    workflow_session_id: Annotated[StrictStr, Field(description="The ID of the workflow session to retrieve the inputs for")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve the inputs of a workflow session.


    :param project_id: (required)
    :type project_id: str
    :param workflow_session_id: The ID of the workflow session to retrieve the inputs for (required)
    :type workflow_session_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workflow_session_inputs_serialize(
        project_id=project_id,
        workflow_session_id=workflow_session_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionInputList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve the inputs of a workflow session.

:param project_id: (required) :type project_id: str :param workflow_session_id: The ID of the workflow session to retrieve the inputs for (required) :type workflow_session_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workflow_sessions(self,
project_id: Annotated[str, Strict(strict=True)],
reference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference to filter on.')] = None,
userreference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-reference to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
usertag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-tags to filter on.')] = None,
technicaltag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical-tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ')] = None) ‑> WorkflowSessionPagedListV3

Expand source code

@validate_call
def get_workflow_sessions(
    self,
    project_id: StrictStr,
    reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
    userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
    technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> WorkflowSessionPagedListV3:
    """(Deprecated) Retrieve the list of workflow sessions.

    This endpoint only returns V3 items. Use the search endpoint to get V4 items.

    :param project_id: (required)
    :type project_id: str
    :param reference: The reference to filter on.
    :type reference: str
    :param userreference: The user-reference to filter on.
    :type userreference: str
    :param status: The status to filter on.
    :type status: str
    :param usertag: The user-tags to filter on.
    :type usertag: str
    :param technicaltag: The technical-tags to filter on.
    :type technicaltag: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/workflowSessions is deprecated.", DeprecationWarning)

    _param = self._get_workflow_sessions_serialize(
        project_id=project_id,
        reference=reference,
        userreference=userreference,
        status=status,
        usertag=usertag,
        technicaltag=technicaltag,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionPagedListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

(Deprecated) Retrieve the list of workflow sessions.

This endpoint only returns V3 items. Use the search endpoint to get V4 items.

:param project_id: (required) :type project_id: str :param reference: The reference to filter on. :type reference: str :param userreference: The user-reference to filter on. :type userreference: str :param status: The status to filter on. :type status: str :param usertag: The user-tags to filter on. :type usertag: str :param technicaltag: The technical-tags to filter on. :type technicaltag: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workflow_sessions_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
reference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference to filter on.')] = None,
userreference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-reference to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
usertag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-tags to filter on.')] = None,
technicaltag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical-tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ')] = None) ‑> ApiResponse[WorkflowSessionPagedListV3]

Expand source code

@validate_call
def get_workflow_sessions_with_http_info(
    self,
    project_id: StrictStr,
    reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
    userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
    technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[WorkflowSessionPagedListV3]:
    """(Deprecated) Retrieve the list of workflow sessions.

    This endpoint only returns V3 items. Use the search endpoint to get V4 items.

    :param project_id: (required)
    :type project_id: str
    :param reference: The reference to filter on.
    :type reference: str
    :param userreference: The user-reference to filter on.
    :type userreference: str
    :param status: The status to filter on.
    :type status: str
    :param usertag: The user-tags to filter on.
    :type usertag: str
    :param technicaltag: The technical-tags to filter on.
    :type technicaltag: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/workflowSessions is deprecated.", DeprecationWarning)

    _param = self._get_workflow_sessions_serialize(
        project_id=project_id,
        reference=reference,
        userreference=userreference,
        status=status,
        usertag=usertag,
        technicaltag=technicaltag,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionPagedListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

(Deprecated) Retrieve the list of workflow sessions.

This endpoint only returns V3 items. Use the search endpoint to get V4 items.

:param project_id: (required) :type project_id: str :param reference: The reference to filter on. :type reference: str :param userreference: The user-reference to filter on. :type userreference: str :param status: The status to filter on. :type status: str :param usertag: The user-tags to filter on. :type usertag: str :param technicaltag: The technical-tags to filter on. :type technicaltag: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workflow_sessions_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
reference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The reference to filter on.')] = None,
userreference: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-reference to filter on.')] = None,
status: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The status to filter on.')] = None,
usertag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user-tags to filter on.')] = None,
technicaltag: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical-tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_workflow_sessions_without_preload_content(
    self,
    project_id: StrictStr,
    reference: Annotated[Optional[StrictStr], Field(description="The reference to filter on.")] = None,
    userreference: Annotated[Optional[StrictStr], Field(description="The user-reference to filter on.")] = None,
    status: Annotated[Optional[StrictStr], Field(description="The status to filter on.")] = None,
    usertag: Annotated[Optional[StrictStr], Field(description="The user-tags to filter on.")] = None,
    technicaltag: Annotated[Optional[StrictStr], Field(description="The technical-tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """(Deprecated) Retrieve the list of workflow sessions.

    This endpoint only returns V3 items. Use the search endpoint to get V4 items.

    :param project_id: (required)
    :type project_id: str
    :param reference: The reference to filter on.
    :type reference: str
    :param userreference: The user-reference to filter on.
    :type userreference: str
    :param status: The status to filter on.
    :type status: str
    :param usertag: The user-tags to filter on.
    :type usertag: str
    :param technicaltag: The technical-tags to filter on.
    :type technicaltag: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501
    warnings.warn("GET /api/projects/{projectId}/workflowSessions is deprecated.", DeprecationWarning)

    _param = self._get_workflow_sessions_serialize(
        project_id=project_id,
        reference=reference,
        userreference=userreference,
        status=status,
        usertag=usertag,
        technicaltag=technicaltag,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionPagedListV3",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

(Deprecated) Retrieve the list of workflow sessions.

This endpoint only returns V3 items. Use the search endpoint to get V4 items.

:param project_id: (required) :type project_id: str :param reference: The reference to filter on. :type reference: str :param userreference: The user-reference to filter on. :type userreference: str :param status: The status to filter on. :type status: str :param usertag: The user-tags to filter on. :type usertag: str :param technicaltag: The technical-tags to filter on. :type technicaltag: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_orchestrated_analyses(self,
project_id: Annotated[str, Strict(strict=True)],
workflow_session_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> WorkflowSessionAnalysisPagedListV4

Expand source code

@validate_call
def search_orchestrated_analyses(
    self,
    project_id: StrictStr,
    workflow_session_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> WorkflowSessionAnalysisPagedListV4:
    """Search analyses orchestrated by the workflow session.


    :param project_id: (required)
    :type project_id: str
    :param workflow_session_id: (required)
    :type workflow_session_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_orchestrated_analyses_serialize(
        project_id=project_id,
        workflow_session_id=workflow_session_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionAnalysisPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Search analyses orchestrated by the workflow session.

:param project_id: (required) :type project_id: str :param workflow_session_id: (required) :type workflow_session_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_orchestrated_analyses_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
workflow_session_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> ApiResponse[WorkflowSessionAnalysisPagedListV4]

Expand source code

@validate_call
def search_orchestrated_analyses_with_http_info(
    self,
    project_id: StrictStr,
    workflow_session_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[WorkflowSessionAnalysisPagedListV4]:
    """Search analyses orchestrated by the workflow session.


    :param project_id: (required)
    :type project_id: str
    :param workflow_session_id: (required)
    :type workflow_session_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_orchestrated_analyses_serialize(
        project_id=project_id,
        workflow_session_id=workflow_session_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionAnalysisPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Search analyses orchestrated by the workflow session.

:param project_id: (required) :type project_id: str :param workflow_session_id: (required) :type workflow_session_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_orchestrated_analyses_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
workflow_session_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def search_orchestrated_analyses_without_preload_content(
    self,
    project_id: StrictStr,
    workflow_session_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Search analyses orchestrated by the workflow session.


    :param project_id: (required)
    :type project_id: str
    :param workflow_session_id: (required)
    :type workflow_session_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_orchestrated_analyses_serialize(
        project_id=project_id,
        workflow_session_id=workflow_session_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionAnalysisPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Search analyses orchestrated by the workflow session.

:param project_id: (required) :type project_id: str :param workflow_session_id: (required) :type workflow_session_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - summary :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_workflow_sessions(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> WorkflowSessionPagedListV4

Expand source code

@validate_call
def search_workflow_sessions(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> WorkflowSessionPagedListV4:
    """Search workflow sessions.


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_workflow_sessions_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Search workflow sessions.

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_workflow_sessions_with_http_info(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> ApiResponse[WorkflowSessionPagedListV4]

Expand source code

@validate_call
def search_workflow_sessions_with_http_info(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[WorkflowSessionPagedListV4]:
    """Search workflow sessions.


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_workflow_sessions_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Search workflow sessions.

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def search_workflow_sessions_without_preload_content(self,
project_id: Annotated[str, Strict(strict=True)],
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ')] = None,
analysis_query_parameters: AnalysisQueryParameters | None = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def search_workflow_sessions_without_preload_content(
    self,
    project_id: StrictStr,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow ")] = None,
    analysis_query_parameters: Optional[AnalysisQueryParameters] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Search workflow sessions.


    :param project_id: (required)
    :type project_id: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow 
    :type sort: str
    :param analysis_query_parameters:
    :type analysis_query_parameters: AnalysisQueryParameters
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._search_workflow_sessions_serialize(
        project_id=project_id,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        analysis_query_parameters=analysis_query_parameters,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkflowSessionPagedListV4",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Search workflow sessions.

:param project_id: (required) :type project_id: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - reference - userReference - pipeline - status - startDate - endDate - workflow :type sort: str :param analysis_query_parameters: :type analysis_query_parameters: AnalysisQueryParameters :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class RcloneTempCredentials (**data: Any)

Expand source code

class RcloneTempCredentials(BaseModel):
    """
    RcloneTempCredentials
    """ # noqa: E501
    config: Dict[str, StrictStr] = Field(description="The config in key value format.")
    file_path_prefix: StrictStr = Field(description="The prefix of the file path.", alias="filePathPrefix")
    storage_type: StrictStr = Field(description="The type of the object storage.", alias="storageType")
    expiration_time: StrictStr = Field(description="The timestamp when the credentials expire.", alias="expirationTime")
    upload_session_id: Optional[StrictStr] = Field(default=None, description="The folder upload session id which can be used after upload to complete the upload session.", alias="uploadSessionId")
    __properties: ClassVar[List[str]] = ["config", "filePathPrefix", "storageType", "expirationTime", "uploadSessionId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of RcloneTempCredentials from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if upload_session_id (nullable) is None
        # and model_fields_set contains the field
        if self.upload_session_id is None and "upload_session_id" in self.model_fields_set:
            _dict['uploadSessionId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of RcloneTempCredentials from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "config": obj.get("config"),
            "filePathPrefix": obj.get("filePathPrefix"),
            "storageType": obj.get("storageType"),
            "expirationTime": obj.get("expirationTime"),
            "uploadSessionId": obj.get("uploadSessionId")
        })
        return _obj

RcloneTempCredentials

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var config : Dict[str, str]

The type of the None singleton.

var expiration_time : str

The type of the None singleton.

var file_path_prefix : str

The type of the None singleton.

var model_config

The type of the None singleton.

var storage_type : str

The type of the None singleton.

var upload_session_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of RcloneTempCredentials from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of RcloneTempCredentials from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if upload_session_id (nullable) is None
    # and model_fields_set contains the field
    if self.upload_session_id is None and "upload_session_id" in self.model_fields_set:
        _dict['uploadSessionId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ReferenceData (**data: Any)

Expand source code

class ReferenceData(BaseModel):
    """
    ReferenceData
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the reference data")
    species: Optional[Species] = None
    data_format: Optional[DataFormat] = Field(default=None, alias="dataFormat")
    version: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The version of the reference data")
    type_list: ReferenceDataTypeList = Field(alias="typeList")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "species", "dataFormat", "version", "typeList"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ReferenceData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of species
        if self.species:
            _dict['species'] = self.species.to_dict()
        # override the default output from pydantic by calling `to_dict()` of data_format
        if self.data_format:
            _dict['dataFormat'] = self.data_format.to_dict()
        # override the default output from pydantic by calling `to_dict()` of type_list
        if self.type_list:
            _dict['typeList'] = self.type_list.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if data_format (nullable) is None
        # and model_fields_set contains the field
        if self.data_format is None and "data_format" in self.model_fields_set:
            _dict['dataFormat'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ReferenceData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "species": Species.from_dict(obj["species"]) if obj.get("species") is not None else None,
            "dataFormat": DataFormat.from_dict(obj["dataFormat"]) if obj.get("dataFormat") is not None else None,
            "version": obj.get("version"),
            "typeList": ReferenceDataTypeList.from_dict(obj["typeList"]) if obj.get("typeList") is not None else None
        })
        return _obj

ReferenceData

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_format : DataFormat | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var species : Species | None

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var type_list : ReferenceDataTypeList

The type of the None singleton.

var version : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ReferenceData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ReferenceData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of species
    if self.species:
        _dict['species'] = self.species.to_dict()
    # override the default output from pydantic by calling `to_dict()` of data_format
    if self.data_format:
        _dict['dataFormat'] = self.data_format.to_dict()
    # override the default output from pydantic by calling `to_dict()` of type_list
    if self.type_list:
        _dict['typeList'] = self.type_list.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if data_format (nullable) is None
    # and model_fields_set contains the field
    if self.data_format is None and "data_format" in self.model_fields_set:
        _dict['dataFormat'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ReferenceDataList (**data: Any)

Expand source code

class ReferenceDataList(BaseModel):
    """
    ReferenceDataList
    """ # noqa: E501
    items: List[ReferenceData]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ReferenceDataList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ReferenceDataList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ReferenceData.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ReferenceDataList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ReferenceData]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ReferenceDataList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ReferenceDataList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ReferenceDataType (**data: Any)

Expand source code

class ReferenceDataType(BaseModel):
    """
    ReferenceDataType
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the reference data type")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ReferenceDataType from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ReferenceDataType from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name")
        })
        return _obj

ReferenceDataType

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ReferenceDataType from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ReferenceDataType from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ReferenceDataTypeList (**data: Any)

Expand source code

class ReferenceDataTypeList(BaseModel):
    """
    ReferenceDataTypeList
    """ # noqa: E501
    items: List[ReferenceDataType]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ReferenceDataTypeList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ReferenceDataTypeList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ReferenceDataType.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ReferenceDataTypeList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ReferenceDataType]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ReferenceDataTypeList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ReferenceDataTypeList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ReferenceSet (**data: Any)

Expand source code

class ReferenceSet(BaseModel):
    """
    ReferenceSet
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the reference set")
    reference_data_list: ReferenceDataList = Field(alias="referenceDataList")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "referenceDataList"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ReferenceSet from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of reference_data_list
        if self.reference_data_list:
            _dict['referenceDataList'] = self.reference_data_list.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ReferenceSet from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "referenceDataList": ReferenceDataList.from_dict(obj["referenceDataList"]) if obj.get("referenceDataList") is not None else None
        })
        return _obj

ReferenceSet

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var reference_data_list : ReferenceDataList

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ReferenceSet from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ReferenceSet from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of reference_data_list
    if self.reference_data_list:
        _dict['referenceDataList'] = self.reference_data_list.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ReferenceSetApi (api_client=None)

Expand source code

class ReferenceSetApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_reference_sets(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ReferenceSetList:
        """Retrieve a list of of reference sets.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_reference_sets_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ReferenceSetList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_reference_sets_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[ReferenceSetList]:
        """Retrieve a list of of reference sets.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_reference_sets_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ReferenceSetList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_reference_sets_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of of reference sets.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_reference_sets_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "ReferenceSetList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_reference_sets_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/referenceSets',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_species(
        self,
        reference_set_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> SpeciesList:
        """Retrieve a list of species linked to the reference set.


        :param reference_set_id: (required)
        :type reference_set_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_species_serialize(
            reference_set_id=reference_set_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SpeciesList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_species_with_http_info(
        self,
        reference_set_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[SpeciesList]:
        """Retrieve a list of species linked to the reference set.


        :param reference_set_id: (required)
        :type reference_set_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_species_serialize(
            reference_set_id=reference_set_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SpeciesList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_species_without_preload_content(
        self,
        reference_set_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of species linked to the reference set.


        :param reference_set_id: (required)
        :type reference_set_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_species_serialize(
            reference_set_id=reference_set_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SpeciesList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_species_serialize(
        self,
        reference_set_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if reference_set_id is not None:
            _path_params['referenceSetId'] = reference_set_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/referenceSets/{referenceSetId}/species',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_reference_sets(self) ‑> ReferenceSetList

Expand source code

@validate_call
def get_reference_sets(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ReferenceSetList:
    """Retrieve a list of of reference sets.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_reference_sets_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ReferenceSetList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of of reference sets.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_reference_sets_with_http_info(self) ‑> ApiResponse[ReferenceSetList]

Expand source code

@validate_call
def get_reference_sets_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[ReferenceSetList]:
    """Retrieve a list of of reference sets.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_reference_sets_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ReferenceSetList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of of reference sets.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_reference_sets_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_reference_sets_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of of reference sets.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_reference_sets_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "ReferenceSetList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of of reference sets.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_species(self, reference_set_id: Annotated[str, Strict(strict=True)]) ‑> SpeciesList

Expand source code

@validate_call
def get_species(
    self,
    reference_set_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> SpeciesList:
    """Retrieve a list of species linked to the reference set.


    :param reference_set_id: (required)
    :type reference_set_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_species_serialize(
        reference_set_id=reference_set_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SpeciesList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of species linked to the reference set.

:param reference_set_id: (required) :type reference_set_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_species_with_http_info(self, reference_set_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[SpeciesList]

Expand source code

@validate_call
def get_species_with_http_info(
    self,
    reference_set_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[SpeciesList]:
    """Retrieve a list of species linked to the reference set.


    :param reference_set_id: (required)
    :type reference_set_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_species_serialize(
        reference_set_id=reference_set_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SpeciesList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of species linked to the reference set.

:param reference_set_id: (required) :type reference_set_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_species_without_preload_content(self, reference_set_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_species_without_preload_content(
    self,
    reference_set_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of species linked to the reference set.


    :param reference_set_id: (required)
    :type reference_set_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_species_serialize(
        reference_set_id=reference_set_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SpeciesList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of species linked to the reference set.

:param reference_set_id: (required) :type reference_set_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class ReferenceSetList (**data: Any)

Expand source code

class ReferenceSetList(BaseModel):
    """
    ReferenceSetList
    """ # noqa: E501
    items: List[ReferenceSet]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ReferenceSetList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ReferenceSetList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [ReferenceSet.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

ReferenceSetList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[ReferenceSet]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ReferenceSetList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ReferenceSetList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Region (**data: Any)

Expand source code

class Region(BaseModel):
    """
    Region
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    country: Country
    city_name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(alias="cityName")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "code", "country", "cityName"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Region from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of country
        if self.country:
            _dict['country'] = self.country.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Region from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "code": obj.get("code"),
            "country": Country.from_dict(obj["country"]) if obj.get("country") is not None else None,
            "cityName": obj.get("cityName")
        })
        return _obj

Region

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var city_name : str

The type of the None singleton.

var code : str

The type of the None singleton.

var country : Country

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Region from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Region from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of country
    if self.country:
        _dict['country'] = self.country.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class RegionApi (api_client=None)

Expand source code

class RegionApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_region(
        self,
        region_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Region:
        """Retrieve a region. Only the regions the user has access to through his/her entitlements can be retrieved.


        :param region_id: (required)
        :type region_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_region_serialize(
            region_id=region_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Region",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_region_with_http_info(
        self,
        region_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Region]:
        """Retrieve a region. Only the regions the user has access to through his/her entitlements can be retrieved.


        :param region_id: (required)
        :type region_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_region_serialize(
            region_id=region_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Region",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_region_without_preload_content(
        self,
        region_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a region. Only the regions the user has access to through his/her entitlements can be retrieved.


        :param region_id: (required)
        :type region_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_region_serialize(
            region_id=region_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Region",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_region_serialize(
        self,
        region_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if region_id is not None:
            _path_params['regionId'] = region_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/regions/{regionId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_regions(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RegionList:
        """Retrieve a list of regions. Only the regions the user has access to through his/her entitlements are returned.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_regions_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "RegionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_regions_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[RegionList]:
        """Retrieve a list of regions. Only the regions the user has access to through his/her entitlements are returned.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_regions_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "RegionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_regions_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of regions. Only the regions the user has access to through his/her entitlements are returned.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_regions_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "RegionList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_regions_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/regions',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_region(self, region_id: Annotated[str, Strict(strict=True)]) ‑> Region

Expand source code

@validate_call
def get_region(
    self,
    region_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Region:
    """Retrieve a region. Only the regions the user has access to through his/her entitlements can be retrieved.


    :param region_id: (required)
    :type region_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_region_serialize(
        region_id=region_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Region",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a region. Only the regions the user has access to through his/her entitlements can be retrieved.

:param region_id: (required) :type region_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_region_with_http_info(self, region_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[Region]

Expand source code

@validate_call
def get_region_with_http_info(
    self,
    region_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Region]:
    """Retrieve a region. Only the regions the user has access to through his/her entitlements can be retrieved.


    :param region_id: (required)
    :type region_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_region_serialize(
        region_id=region_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Region",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a region. Only the regions the user has access to through his/her entitlements can be retrieved.

:param region_id: (required) :type region_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_region_without_preload_content(self, region_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_region_without_preload_content(
    self,
    region_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a region. Only the regions the user has access to through his/her entitlements can be retrieved.


    :param region_id: (required)
    :type region_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_region_serialize(
        region_id=region_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Region",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a region. Only the regions the user has access to through his/her entitlements can be retrieved.

:param region_id: (required) :type region_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_regions(self) ‑> RegionList

Expand source code

@validate_call
def get_regions(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RegionList:
    """Retrieve a list of regions. Only the regions the user has access to through his/her entitlements are returned.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_regions_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "RegionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of regions. Only the regions the user has access to through his/her entitlements are returned.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_regions_with_http_info(self) ‑> ApiResponse[RegionList]

Expand source code

@validate_call
def get_regions_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[RegionList]:
    """Retrieve a list of regions. Only the regions the user has access to through his/her entitlements are returned.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_regions_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "RegionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of regions. Only the regions the user has access to through his/her entitlements are returned.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_regions_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_regions_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of regions. Only the regions the user has access to through his/her entitlements are returned.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_regions_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "RegionList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of regions. Only the regions the user has access to through his/her entitlements are returned.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class RegionList (**data: Any)

Expand source code

class RegionList(BaseModel):
    """
    RegionList
    """ # noqa: E501
    items: List[Region]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of RegionList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of RegionList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Region.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

RegionList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Region]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of RegionList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of RegionList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class RegionV4 (**data: Any)

Expand source code

class RegionV4(BaseModel):
    """
    RegionV4
    """ # noqa: E501
    id: StrictStr
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    __properties: ClassVar[List[str]] = ["id", "code"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of RegionV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of RegionV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "code": obj.get("code")
        })
        return _obj

RegionV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var code : str

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of RegionV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of RegionV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Sample (**data: Any)

Expand source code

class Sample(BaseModel):
    """
    Sample
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the sample")
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = Field(default=None, description="The description of the sample")
    tags: SampleTag
    region: Region
    application: Optional[ApplicationV4] = None
    status: StrictStr
    metadata_valid: StrictBool = Field(description="Whether the metadata is valid", alias="metadataValid")
    metadata: List[MetadataField] = Field(description="The metadata of the sample")
    sequencing_runs: Optional[List[Optional[SequencingRun]]] = Field(default=None, alias="sequencingRuns")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "description", "tags", "region", "application", "status", "metadataValid", "metadata", "sequencingRuns"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['DELETED', 'AVAILABLE', 'PARTIAL']):
            raise ValueError("must be one of enum values ('DELETED', 'AVAILABLE', 'PARTIAL')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Sample from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of region
        if self.region:
            _dict['region'] = self.region.to_dict()
        # override the default output from pydantic by calling `to_dict()` of application
        if self.application:
            _dict['application'] = self.application.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in metadata (list)
        _items = []
        if self.metadata:
            for _item_metadata in self.metadata:
                if _item_metadata:
                    _items.append(_item_metadata.to_dict())
            _dict['metadata'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in sequencing_runs (list)
        _items = []
        if self.sequencing_runs:
            for _item_sequencing_runs in self.sequencing_runs:
                if _item_sequencing_runs:
                    _items.append(_item_sequencing_runs.to_dict())
            _dict['sequencingRuns'] = _items
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if application (nullable) is None
        # and model_fields_set contains the field
        if self.application is None and "application" in self.model_fields_set:
            _dict['application'] = None

        # set to None if sequencing_runs (nullable) is None
        # and model_fields_set contains the field
        if self.sequencing_runs is None and "sequencing_runs" in self.model_fields_set:
            _dict['sequencingRuns'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Sample from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "description": obj.get("description"),
            "tags": SampleTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None,
            "region": Region.from_dict(obj["region"]) if obj.get("region") is not None else None,
            "application": ApplicationV4.from_dict(obj["application"]) if obj.get("application") is not None else None,
            "status": obj.get("status"),
            "metadataValid": obj.get("metadataValid"),
            "metadata": [MetadataField.from_dict(_item) for _item in obj["metadata"]] if obj.get("metadata") is not None else None,
            "sequencingRuns": [SequencingRun.from_dict(_item) for _item in obj["sequencingRuns"]] if obj.get("sequencingRuns") is not None else None
        })
        return _obj

Sample

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var application : ApplicationV4 | None

The type of the None singleton.

var description : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var metadata : List[MetadataField]

The type of the None singleton.

var metadata_valid : bool

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var region : Region

The type of the None singleton.

var sequencing_runs : List[SequencingRun | None] | None

The type of the None singleton.

var status : str

The type of the None singleton.

var tags : SampleTag

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Sample from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Sample from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of region
    if self.region:
        _dict['region'] = self.region.to_dict()
    # override the default output from pydantic by calling `to_dict()` of application
    if self.application:
        _dict['application'] = self.application.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in metadata (list)
    _items = []
    if self.metadata:
        for _item_metadata in self.metadata:
            if _item_metadata:
                _items.append(_item_metadata.to_dict())
        _dict['metadata'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in sequencing_runs (list)
    _items = []
    if self.sequencing_runs:
        for _item_sequencing_runs in self.sequencing_runs:
            if _item_sequencing_runs:
                _items.append(_item_sequencing_runs.to_dict())
        _dict['sequencingRuns'] = _items
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if application (nullable) is None
    # and model_fields_set contains the field
    if self.application is None and "application" in self.model_fields_set:
        _dict['application'] = None

    # set to None if sequencing_runs (nullable) is None
    # and model_fields_set contains the field
    if self.sequencing_runs is None and "sequencing_runs" in self.model_fields_set:
        _dict['sequencingRuns'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SampleApi (api_client=None)

Expand source code

class SampleApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_samples(
        self,
        region: Annotated[StrictStr, Field(description="The ID of the region to filter on. This parameter is required.")],
        search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> SamplePagedList:
        """Retrieve a list of samples.


        :param region: The ID of the region to filter on. This parameter is required. (required)
        :type region: str
        :param search: To search through multiple fields of data.
        :type search: str
        :param user_tags: The user tags to filter on.
        :type user_tags: str
        :param technical_tags: The technical tags to filter on.
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_samples_serialize(
            region=region,
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SamplePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_samples_with_http_info(
        self,
        region: Annotated[StrictStr, Field(description="The ID of the region to filter on. This parameter is required.")],
        search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[SamplePagedList]:
        """Retrieve a list of samples.


        :param region: The ID of the region to filter on. This parameter is required. (required)
        :type region: str
        :param search: To search through multiple fields of data.
        :type search: str
        :param user_tags: The user tags to filter on.
        :type user_tags: str
        :param technical_tags: The technical tags to filter on.
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_samples_serialize(
            region=region,
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SamplePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_samples_without_preload_content(
        self,
        region: Annotated[StrictStr, Field(description="The ID of the region to filter on. This parameter is required.")],
        search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
        user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
        technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
        page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
        page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
        page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
        sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of samples.


        :param region: The ID of the region to filter on. This parameter is required. (required)
        :type region: str
        :param search: To search through multiple fields of data.
        :type search: str
        :param user_tags: The user tags to filter on.
        :type user_tags: str
        :param technical_tags: The technical tags to filter on.
        :type technical_tags: str
        :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
        :type page_offset: str
        :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
        :type page_token: str
        :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
        :type page_size: str
        :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
        :type sort: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_samples_serialize(
            region=region,
            search=search,
            user_tags=user_tags,
            technical_tags=technical_tags,
            page_offset=page_offset,
            page_token=page_token,
            page_size=page_size,
            sort=sort,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SamplePagedList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_samples_serialize(
        self,
        region,
        search,
        user_tags,
        technical_tags,
        page_offset,
        page_token,
        page_size,
        sort,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if region is not None:
            
            _query_params.append(('region', region))
            
        if search is not None:
            
            _query_params.append(('search', search))
            
        if user_tags is not None:
            
            _query_params.append(('userTags', user_tags))
            
        if technical_tags is not None:
            
            _query_params.append(('technicalTags', technical_tags))
            
        if page_offset is not None:
            
            _query_params.append(('pageOffset', page_offset))
            
        if page_token is not None:
            
            _query_params.append(('pageToken', page_token))
            
        if page_size is not None:
            
            _query_params.append(('pageSize', page_size))
            
        if sort is not None:
            
            _query_params.append(('sort', sort))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/samples',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_samples(self,
region: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the region to filter on. This parameter is required.')],
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user tags to filter on.')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status')] = None) ‑> SamplePagedList

Expand source code

@validate_call
def get_samples(
    self,
    region: Annotated[StrictStr, Field(description="The ID of the region to filter on. This parameter is required.")],
    search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> SamplePagedList:
    """Retrieve a list of samples.


    :param region: The ID of the region to filter on. This parameter is required. (required)
    :type region: str
    :param search: To search through multiple fields of data.
    :type search: str
    :param user_tags: The user tags to filter on.
    :type user_tags: str
    :param technical_tags: The technical tags to filter on.
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_samples_serialize(
        region=region,
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SamplePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of samples.

:param region: The ID of the region to filter on. This parameter is required. (required) :type region: str :param search: To search through multiple fields of data. :type search: str :param user_tags: The user tags to filter on. :type user_tags: str :param technical_tags: The technical tags to filter on. :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_samples_with_http_info(self,
region: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the region to filter on. This parameter is required.')],
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user tags to filter on.')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status')] = None) ‑> ApiResponse[SamplePagedList]

Expand source code

@validate_call
def get_samples_with_http_info(
    self,
    region: Annotated[StrictStr, Field(description="The ID of the region to filter on. This parameter is required.")],
    search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[SamplePagedList]:
    """Retrieve a list of samples.


    :param region: The ID of the region to filter on. This parameter is required. (required)
    :type region: str
    :param search: To search through multiple fields of data.
    :type search: str
    :param user_tags: The user tags to filter on.
    :type user_tags: str
    :param technical_tags: The technical tags to filter on.
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_samples_serialize(
        region=region,
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SamplePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of samples.

:param region: The ID of the region to filter on. This parameter is required. (required) :type region: str :param search: To search through multiple fields of data. :type search: str :param user_tags: The user tags to filter on. :type user_tags: str :param technical_tags: The technical tags to filter on. :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_samples_without_preload_content(self,
region: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the region to filter on. This parameter is required.')],
search: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='To search through multiple fields of data.')] = None,
user_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The user tags to filter on.')] = None,
technical_tags: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The technical tags to filter on.')] = None,
page_offset: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages')] = None,
page_token: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.')] = None,
page_size: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results')] = None,
sort: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='[only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with \' desc\' to sort descending (suffix \' asc\' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_samples_without_preload_content(
    self,
    region: Annotated[StrictStr, Field(description="The ID of the region to filter on. This parameter is required.")],
    search: Annotated[Optional[StrictStr], Field(description="To search through multiple fields of data.")] = None,
    user_tags: Annotated[Optional[StrictStr], Field(description="The user tags to filter on.")] = None,
    technical_tags: Annotated[Optional[StrictStr], Field(description="The technical tags to filter on.")] = None,
    page_offset: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages")] = None,
    page_token: Annotated[Optional[StrictStr], Field(description="[only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.")] = None,
    page_size: Annotated[Optional[StrictStr], Field(description="[can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results")] = None,
    sort: Annotated[Optional[StrictStr], Field(description="[only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of samples.


    :param region: The ID of the region to filter on. This parameter is required. (required)
    :type region: str
    :param search: To search through multiple fields of data.
    :type search: str
    :param user_tags: The user tags to filter on.
    :type user_tags: str
    :param technical_tags: The technical tags to filter on.
    :type technical_tags: str
    :param page_offset: [only use with offset-based paging]<br>The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages
    :type page_offset: str
    :param page_token: [only use with cursor-based paging]<br>The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages.
    :type page_token: str
    :param page_size: [can be used with both offset- and cursor-based paging]<br>The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results
    :type page_size: str
    :param sort: [only use with offset-based paging]<br>Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: \"?sort=sortAttribute1, sortAttribute2 desc\"  The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status
    :type sort: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_samples_serialize(
        region=region,
        search=search,
        user_tags=user_tags,
        technical_tags=technical_tags,
        page_offset=page_offset,
        page_token=page_token,
        page_size=page_size,
        sort=sort,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SamplePagedList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of samples.

:param region: The ID of the region to filter on. This parameter is required. (required) :type region: str :param search: To search through multiple fields of data. :type search: str :param user_tags: The user tags to filter on. :type user_tags: str :param technical_tags: The technical tags to filter on. :type technical_tags: str :param page_offset: [only use with offset-based paging]
The amount of rows to skip in the result. Ideally this is a multiple of the size parameter. Offset-based pagination has a result limit of 200K rows and does not guarantee unique results across pages :type page_offset: str :param page_token: [only use with cursor-based paging]
The cursor to get subsequent results. The value to use is returned in the result when using cursor-based pagination. Cursor-based pagination guarantees complete and unique results across all pages. :type page_token: str :param page_size: [can be used with both offset- and cursor-based paging]
The amount of rows to return. Use in combination with the offset (when using offset-based pagination) or cursor (when using cursor-based pagination) parameter to get subsequent results :type page_size: str :param sort: [only use with offset-based paging]
Which field to order the results by. The default order is ascending, suffix with ' desc' to sort descending (suffix ' asc' also works for ascending). Multiple values should be separated with commas. An example: "?sort=sortAttribute1, sortAttribute2 desc" The attributes for which sorting is supported: - timeCreated - timeModified - name - description - metadataValid - status :type sort: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class SampleCreationBatch (**data: Any)

Expand source code

class SampleCreationBatch(BaseModel):
    """
    SampleCreationBatch
    """ # noqa: E501
    id: StrictStr
    job: Optional[Job] = None
    sequencing_run_id: Optional[StrictStr] = Field(default=None, description="The sequencingRunId to link to all created samples and linked data", alias="sequencingRunId")
    __properties: ClassVar[List[str]] = ["id", "job", "sequencingRunId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SampleCreationBatch from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of job
        if self.job:
            _dict['job'] = self.job.to_dict()
        # set to None if job (nullable) is None
        # and model_fields_set contains the field
        if self.job is None and "job" in self.model_fields_set:
            _dict['job'] = None

        # set to None if sequencing_run_id (nullable) is None
        # and model_fields_set contains the field
        if self.sequencing_run_id is None and "sequencing_run_id" in self.model_fields_set:
            _dict['sequencingRunId'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SampleCreationBatch from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "job": Job.from_dict(obj["job"]) if obj.get("job") is not None else None,
            "sequencingRunId": obj.get("sequencingRunId")
        })
        return _obj

SampleCreationBatch

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var job : Job | None

The type of the None singleton.

var model_config

The type of the None singleton.

var sequencing_run_id : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SampleCreationBatch from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SampleCreationBatch from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of job
    if self.job:
        _dict['job'] = self.job.to_dict()
    # set to None if job (nullable) is None
    # and model_fields_set contains the field
    if self.job is None and "job" in self.model_fields_set:
        _dict['job'] = None

    # set to None if sequencing_run_id (nullable) is None
    # and model_fields_set contains the field
    if self.sequencing_run_id is None and "sequencing_run_id" in self.model_fields_set:
        _dict['sequencingRunId'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SampleCreationBatchItemPagedList (**data: Any)

Expand source code

class SampleCreationBatchItemPagedList(BaseModel):
    """
    SampleCreationBatchItemPagedList
    """ # noqa: E501
    items: List[SampleCreationBatchSampleItem]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SampleCreationBatchItemPagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SampleCreationBatchItemPagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [SampleCreationBatchSampleItem.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

SampleCreationBatchItemPagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[SampleCreationBatchSampleItem]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SampleCreationBatchItemPagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SampleCreationBatchItemPagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SampleCreationBatchItemProcessing (**data: Any)

Expand source code

class SampleCreationBatchItemProcessing(BaseModel):
    """
    SampleCreationBatchItemProcessing
    """ # noqa: E501
    status: StrictStr
    additional_status_information: Optional[StrictStr] = Field(default=None, description="Additional information regarding the status of this batch item.", alias="additionalStatusInformation")
    __properties: ClassVar[List[str]] = ["status", "additionalStatusInformation"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['INITIALIZED', 'WAITING_RESOURCES', 'RUNNING', 'SUCCEEDED', 'PARTIALLY_SUCCEEDED', 'FAILED', 'STOPPED']):
            raise ValueError("must be one of enum values ('INITIALIZED', 'WAITING_RESOURCES', 'RUNNING', 'SUCCEEDED', 'PARTIALLY_SUCCEEDED', 'FAILED', 'STOPPED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SampleCreationBatchItemProcessing from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if additional_status_information (nullable) is None
        # and model_fields_set contains the field
        if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
            _dict['additionalStatusInformation'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SampleCreationBatchItemProcessing from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "status": obj.get("status"),
            "additionalStatusInformation": obj.get("additionalStatusInformation")
        })
        return _obj

SampleCreationBatchItemProcessing

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var additional_status_information : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var status : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SampleCreationBatchItemProcessing from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SampleCreationBatchItemProcessing from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if additional_status_information (nullable) is None
    # and model_fields_set contains the field
    if self.additional_status_information is None and "additional_status_information" in self.model_fields_set:
        _dict['additionalStatusInformation'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SampleCreationBatchItemRequest (**data: Any)

Expand source code

class SampleCreationBatchItemRequest(BaseModel):
    """
    SampleCreationBatchItemRequest
    """ # noqa: E501
    sample_to_create: CreateSample = Field(alias="sampleToCreate")
    complete_sample: StrictBool = Field(description="Indicates whether the sample must be completed.", alias="completeSample")
    __properties: ClassVar[List[str]] = ["sampleToCreate", "completeSample"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SampleCreationBatchItemRequest from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of sample_to_create
        if self.sample_to_create:
            _dict['sampleToCreate'] = self.sample_to_create.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SampleCreationBatchItemRequest from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "sampleToCreate": CreateSample.from_dict(obj["sampleToCreate"]) if obj.get("sampleToCreate") is not None else None,
            "completeSample": obj.get("completeSample")
        })
        return _obj

SampleCreationBatchItemRequest

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var complete_sample : bool

The type of the None singleton.

var model_config

The type of the None singleton.

var sample_to_create : CreateSample

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SampleCreationBatchItemRequest from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SampleCreationBatchItemRequest from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of sample_to_create
    if self.sample_to_create:
        _dict['sampleToCreate'] = self.sample_to_create.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SampleCreationBatchSampleItem (**data: Any)

Expand source code

class SampleCreationBatchSampleItem(BaseModel):
    """
    SampleCreationBatchSampleItem
    """ # noqa: E501
    id: StrictStr
    request: SampleCreationBatchItemRequest
    processing: SampleCreationBatchItemProcessing
    created_sample: Optional[Sample] = Field(default=None, alias="createdSample")
    __properties: ClassVar[List[str]] = ["id", "request", "processing", "createdSample"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SampleCreationBatchSampleItem from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of request
        if self.request:
            _dict['request'] = self.request.to_dict()
        # override the default output from pydantic by calling `to_dict()` of processing
        if self.processing:
            _dict['processing'] = self.processing.to_dict()
        # override the default output from pydantic by calling `to_dict()` of created_sample
        if self.created_sample:
            _dict['createdSample'] = self.created_sample.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SampleCreationBatchSampleItem from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "request": SampleCreationBatchItemRequest.from_dict(obj["request"]) if obj.get("request") is not None else None,
            "processing": SampleCreationBatchItemProcessing.from_dict(obj["processing"]) if obj.get("processing") is not None else None,
            "createdSample": Sample.from_dict(obj["createdSample"]) if obj.get("createdSample") is not None else None
        })
        return _obj

SampleCreationBatchSampleItem

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var created_sample : Sample | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var processing : SampleCreationBatchItemProcessing

The type of the None singleton.

var request : SampleCreationBatchItemRequest

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SampleCreationBatchSampleItem from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SampleCreationBatchSampleItem from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of request
    if self.request:
        _dict['request'] = self.request.to_dict()
    # override the default output from pydantic by calling `to_dict()` of processing
    if self.processing:
        _dict['processing'] = self.processing.to_dict()
    # override the default output from pydantic by calling `to_dict()` of created_sample
    if self.created_sample:
        _dict['createdSample'] = self.created_sample.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SampleHistory (**data: Any)

Expand source code

class SampleHistory(BaseModel):
    """
    SampleHistory
    """ # noqa: E501
    occurred_at: datetime = Field(description="When the change was made", alias="occurredAt")
    user: Optional[StrictStr] = Field(default=None, description="The user that made the change")
    run: Optional[StrictStr] = Field(default=None, description="In which execution context the change was made")
    source: StrictStr = Field(description="In which context the change was made")
    text: StrictStr = Field(description="What was changed")
    project: Optional[StrictStr] = Field(default=None, description="In which project context the change was made")
    model: Optional[StrictInt] = Field(default=None, description="In which model context the change was made")
    __properties: ClassVar[List[str]] = ["occurredAt", "user", "run", "source", "text", "project", "model"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SampleHistory from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if user (nullable) is None
        # and model_fields_set contains the field
        if self.user is None and "user" in self.model_fields_set:
            _dict['user'] = None

        # set to None if run (nullable) is None
        # and model_fields_set contains the field
        if self.run is None and "run" in self.model_fields_set:
            _dict['run'] = None

        # set to None if project (nullable) is None
        # and model_fields_set contains the field
        if self.project is None and "project" in self.model_fields_set:
            _dict['project'] = None

        # set to None if model (nullable) is None
        # and model_fields_set contains the field
        if self.model is None and "model" in self.model_fields_set:
            _dict['model'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SampleHistory from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "occurredAt": obj.get("occurredAt"),
            "user": obj.get("user"),
            "run": obj.get("run"),
            "source": obj.get("source"),
            "text": obj.get("text"),
            "project": obj.get("project"),
            "model": obj.get("model")
        })
        return _obj

SampleHistory

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model : int | None

The type of the None singleton.

var model_config

The type of the None singleton.

var occurred_at : datetime.datetime

The type of the None singleton.

var project : str | None

The type of the None singleton.

var run : str | None

The type of the None singleton.

var source : str

The type of the None singleton.

var text : str

The type of the None singleton.

var user : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SampleHistory from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SampleHistory from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if user (nullable) is None
    # and model_fields_set contains the field
    if self.user is None and "user" in self.model_fields_set:
        _dict['user'] = None

    # set to None if run (nullable) is None
    # and model_fields_set contains the field
    if self.run is None and "run" in self.model_fields_set:
        _dict['run'] = None

    # set to None if project (nullable) is None
    # and model_fields_set contains the field
    if self.project is None and "project" in self.model_fields_set:
        _dict['project'] = None

    # set to None if model (nullable) is None
    # and model_fields_set contains the field
    if self.model is None and "model" in self.model_fields_set:
        _dict['model'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SampleHistoryList (**data: Any)

Expand source code

class SampleHistoryList(BaseModel):
    """
    SampleHistoryList
    """ # noqa: E501
    items: List[SampleHistory]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SampleHistoryList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SampleHistoryList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [SampleHistory.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

SampleHistoryList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[SampleHistory]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SampleHistoryList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SampleHistoryList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SamplePagedList (**data: Any)

Expand source code

class SamplePagedList(BaseModel):
    """
    SamplePagedList
    """ # noqa: E501
    items: List[Sample]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SamplePagedList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SamplePagedList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Sample.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

SamplePagedList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Sample]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SamplePagedList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SamplePagedList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SampleTag (**data: Any)

Expand source code

class SampleTag(BaseModel):
    """
    SampleTag
    """ # noqa: E501
    technical_tags: List[StrictStr] = Field(alias="technicalTags")
    user_tags: List[StrictStr] = Field(alias="userTags")
    connector_tags: List[StrictStr] = Field(alias="connectorTags")
    run_in_tags: List[StrictStr] = Field(alias="runInTags")
    __properties: ClassVar[List[str]] = ["technicalTags", "userTags", "connectorTags", "runInTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SampleTag from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SampleTag from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "technicalTags": obj.get("technicalTags"),
            "userTags": obj.get("userTags"),
            "connectorTags": obj.get("connectorTags"),
            "runInTags": obj.get("runInTags")
        })
        return _obj

SampleTag

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var connector_tags : List[str]

The type of the None singleton.

var model_config

The type of the None singleton.

var run_in_tags : List[str]

The type of the None singleton.

var technical_tags : List[str]

The type of the None singleton.

var user_tags : List[str]

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SampleTag from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SampleTag from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class ScheduleDownload (**data: Any)

Expand source code

class ScheduleDownload(BaseModel):
    """
    ScheduleDownload
    """ # noqa: E501
    connector_id: Optional[StrictStr] = Field(default=None, alias="connectorId")
    protocol: Optional[StrictStr] = None
    local_path: Optional[StrictStr] = Field(default=None, alias="localPath")
    disable_hashing: Optional[StrictBool] = Field(default=None, alias="disableHashing")
    __properties: ClassVar[List[str]] = ["connectorId", "protocol", "localPath", "disableHashing"]

    @field_validator('protocol')
    def protocol_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['HTTPS']):
            raise ValueError("must be one of enum values ('HTTPS')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of ScheduleDownload from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of ScheduleDownload from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "connectorId": obj.get("connectorId"),
            "protocol": obj.get("protocol"),
            "localPath": obj.get("localPath"),
            "disableHashing": obj.get("disableHashing")
        })
        return _obj

ScheduleDownload

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var connector_id : str | None

The type of the None singleton.

var disable_hashing : bool | None

The type of the None singleton.

var local_path : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var protocol : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of ScheduleDownload from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of ScheduleDownload from a JSON string

def protocol_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SearchMatchingActivationCodesForCwlAnalysis (**data: Any)

Expand source code

class SearchMatchingActivationCodesForCwlAnalysis(BaseModel):
    """
    SearchMatchingActivationCodesForCwlAnalysis
    """ # noqa: E501
    project_id: StrictStr = Field(alias="projectId")
    pipeline_id: StrictStr = Field(alias="pipelineId")
    analysis_input: CwlAnalysisInput = Field(alias="analysisInput")
    __properties: ClassVar[List[str]] = ["projectId", "pipelineId", "analysisInput"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SearchMatchingActivationCodesForCwlAnalysis from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of analysis_input
        if self.analysis_input:
            _dict['analysisInput'] = self.analysis_input.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SearchMatchingActivationCodesForCwlAnalysis from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "projectId": obj.get("projectId"),
            "pipelineId": obj.get("pipelineId"),
            "analysisInput": CwlAnalysisInput.from_dict(obj["analysisInput"]) if obj.get("analysisInput") is not None else None
        })
        return _obj

SearchMatchingActivationCodesForCwlAnalysis

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_input : CwlAnalysisInput

The type of the None singleton.

var model_config

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var project_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SearchMatchingActivationCodesForCwlAnalysis from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SearchMatchingActivationCodesForCwlAnalysis from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of analysis_input
    if self.analysis_input:
        _dict['analysisInput'] = self.analysis_input.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SearchMatchingActivationCodesForNextflowAnalysis (**data: Any)

Expand source code

class SearchMatchingActivationCodesForNextflowAnalysis(BaseModel):
    """
    SearchMatchingActivationCodesForNextflowAnalysis
    """ # noqa: E501
    project_id: StrictStr = Field(alias="projectId")
    pipeline_id: StrictStr = Field(alias="pipelineId")
    analysis_input: NextflowAnalysisInput = Field(alias="analysisInput")
    __properties: ClassVar[List[str]] = ["projectId", "pipelineId", "analysisInput"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SearchMatchingActivationCodesForNextflowAnalysis from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of analysis_input
        if self.analysis_input:
            _dict['analysisInput'] = self.analysis_input.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SearchMatchingActivationCodesForNextflowAnalysis from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "projectId": obj.get("projectId"),
            "pipelineId": obj.get("pipelineId"),
            "analysisInput": NextflowAnalysisInput.from_dict(obj["analysisInput"]) if obj.get("analysisInput") is not None else None
        })
        return _obj

SearchMatchingActivationCodesForNextflowAnalysis

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_input : NextflowAnalysisInput

The type of the None singleton.

var model_config

The type of the None singleton.

var pipeline_id : str

The type of the None singleton.

var project_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SearchMatchingActivationCodesForNextflowAnalysis from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SearchMatchingActivationCodesForNextflowAnalysis from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of analysis_input
    if self.analysis_input:
        _dict['analysisInput'] = self.analysis_input.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SequencingRun (**data: Any)

Expand source code

class SequencingRun(BaseModel):
    """
    SequencingRun
    """ # noqa: E501
    id: StrictStr
    instrument_run_id: Annotated[str, Field(min_length=0, strict=True, max_length=255)] = Field(alias="instrumentRunId")
    name: Annotated[str, Field(min_length=0, strict=True, max_length=255)]
    __properties: ClassVar[List[str]] = ["id", "instrumentRunId", "name"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SequencingRun from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SequencingRun from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "instrumentRunId": obj.get("instrumentRunId"),
            "name": obj.get("name")
        })
        return _obj

SequencingRun

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var instrument_run_id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SequencingRun from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SequencingRun from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SequencingRunApi (api_client=None)

Expand source code

class SequencingRunApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_sequencing_run(
        self,
        sequencing_run_id: Annotated[StrictStr, Field(description="The ID of the sequencing run to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> SequencingRun:
        """Retrieve a sequencing run.


        :param sequencing_run_id: The ID of the sequencing run to retrieve (required)
        :type sequencing_run_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sequencing_run_serialize(
            sequencing_run_id=sequencing_run_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SequencingRun",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_sequencing_run_with_http_info(
        self,
        sequencing_run_id: Annotated[StrictStr, Field(description="The ID of the sequencing run to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[SequencingRun]:
        """Retrieve a sequencing run.


        :param sequencing_run_id: The ID of the sequencing run to retrieve (required)
        :type sequencing_run_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sequencing_run_serialize(
            sequencing_run_id=sequencing_run_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SequencingRun",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_sequencing_run_without_preload_content(
        self,
        sequencing_run_id: Annotated[StrictStr, Field(description="The ID of the sequencing run to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a sequencing run.


        :param sequencing_run_id: The ID of the sequencing run to retrieve (required)
        :type sequencing_run_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_sequencing_run_serialize(
            sequencing_run_id=sequencing_run_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SequencingRun",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_sequencing_run_serialize(
        self,
        sequencing_run_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if sequencing_run_id is not None:
            _path_params['sequencingRunId'] = sequencing_run_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/sequencingRuns/{sequencingRunId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_sequencing_run(self,
sequencing_run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sequencing run to retrieve')]) ‑> SequencingRun

Expand source code

@validate_call
def get_sequencing_run(
    self,
    sequencing_run_id: Annotated[StrictStr, Field(description="The ID of the sequencing run to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> SequencingRun:
    """Retrieve a sequencing run.


    :param sequencing_run_id: The ID of the sequencing run to retrieve (required)
    :type sequencing_run_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sequencing_run_serialize(
        sequencing_run_id=sequencing_run_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SequencingRun",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a sequencing run.

:param sequencing_run_id: The ID of the sequencing run to retrieve (required) :type sequencing_run_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sequencing_run_with_http_info(self,
sequencing_run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sequencing run to retrieve')]) ‑> ApiResponse[SequencingRun]

Expand source code

@validate_call
def get_sequencing_run_with_http_info(
    self,
    sequencing_run_id: Annotated[StrictStr, Field(description="The ID of the sequencing run to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[SequencingRun]:
    """Retrieve a sequencing run.


    :param sequencing_run_id: The ID of the sequencing run to retrieve (required)
    :type sequencing_run_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sequencing_run_serialize(
        sequencing_run_id=sequencing_run_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SequencingRun",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a sequencing run.

:param sequencing_run_id: The ID of the sequencing run to retrieve (required) :type sequencing_run_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_sequencing_run_without_preload_content(self,
sequencing_run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the sequencing run to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_sequencing_run_without_preload_content(
    self,
    sequencing_run_id: Annotated[StrictStr, Field(description="The ID of the sequencing run to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a sequencing run.


    :param sequencing_run_id: The ID of the sequencing run to retrieve (required)
    :type sequencing_run_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_sequencing_run_serialize(
        sequencing_run_id=sequencing_run_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SequencingRun",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a sequencing run.

:param sequencing_run_id: The ID of the sequencing run to retrieve (required) :type sequencing_run_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class Settings (*args, **kwargs)

Expand source code

class Settings(BaseModel):
    """
    This object contains a \"anyOf\" construct. Depending on which type, you will receive a StringSettings-, IntegerSettings or OptionsSettings object.
    """

    # data type: StringSettings
    anyof_schema_1_validator: Optional[StringSettings] = None
    # data type: IntegerSettings
    anyof_schema_2_validator: Optional[IntegerSettings] = None
    # data type: OptionSettings
    anyof_schema_3_validator: Optional[OptionSettings] = None
    if TYPE_CHECKING:
        actual_instance: Optional[Union[IntegerSettings, OptionSettings, StringSettings]] = None
    else:
        actual_instance: Any = None
    any_of_schemas: Set[str] = { "IntegerSettings", "OptionSettings", "StringSettings" }

    model_config = {
        "validate_assignment": True,
        "protected_namespaces": (),
    }

    def __init__(self, *args, **kwargs) -> None:
        if args:
            if len(args) > 1:
                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
            if kwargs:
                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
            super().__init__(actual_instance=args[0])
        else:
            super().__init__(**kwargs)

    @field_validator('actual_instance')
    def actual_instance_must_validate_anyof(cls, v):
        instance = Settings.model_construct()
        error_messages = []
        # validate data type: StringSettings
        if not isinstance(v, StringSettings):
            error_messages.append(f"Error! Input type `{type(v)}` is not `StringSettings`")
        else:
            return v

        # validate data type: IntegerSettings
        if not isinstance(v, IntegerSettings):
            error_messages.append(f"Error! Input type `{type(v)}` is not `IntegerSettings`")
        else:
            return v

        # validate data type: OptionSettings
        if not isinstance(v, OptionSettings):
            error_messages.append(f"Error! Input type `{type(v)}` is not `OptionSettings`")
        else:
            return v

        if error_messages:
            # no match
            raise ValueError("No match found when setting the actual_instance in Settings with anyOf schemas: IntegerSettings, OptionSettings, StringSettings. Details: " + ", ".join(error_messages))
        else:
            return v

    @classmethod
    def from_dict(cls, obj: Dict[str, Any]) -> Self:
        return cls.from_json(json.dumps(obj))

    @classmethod
    def from_json(cls, json_str: str) -> Self:
        """Returns the object represented by the json string"""
        instance = cls.model_construct()
        error_messages = []
        # anyof_schema_1_validator: Optional[StringSettings] = None
        try:
            instance.actual_instance = StringSettings.from_json(json_str)
            return instance
        except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
        # anyof_schema_2_validator: Optional[IntegerSettings] = None
        try:
            instance.actual_instance = IntegerSettings.from_json(json_str)
            return instance
        except (ValidationError, ValueError) as e:
             error_messages.append(str(e))
        # anyof_schema_3_validator: Optional[OptionSettings] = None
        try:
            instance.actual_instance = OptionSettings.from_json(json_str)
            return instance
        except (ValidationError, ValueError) as e:
             error_messages.append(str(e))

        if error_messages:
            # no match
            raise ValueError("No match found when deserializing the JSON string into Settings with anyOf schemas: IntegerSettings, OptionSettings, StringSettings. Details: " + ", ".join(error_messages))
        else:
            return instance

    def to_json(self) -> str:
        """Returns the JSON representation of the actual instance"""
        if self.actual_instance is None:
            return "null"

        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
            return self.actual_instance.to_json()
        else:
            return json.dumps(self.actual_instance)

    def to_dict(self) -> Optional[Union[Dict[str, Any], IntegerSettings, OptionSettings, StringSettings]]:
        """Returns the dict representation of the actual instance"""
        if self.actual_instance is None:
            return None

        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
            return self.actual_instance.to_dict()
        else:
            return self.actual_instance

    def to_str(self) -> str:
        """Returns the string representation of the actual instance"""
        return pprint.pformat(self.model_dump())

This object contains a "anyOf" construct. Depending on which type, you will receive a StringSettings-, IntegerSettings or OptionsSettings object.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var actual_instance : Any

The type of the None singleton.

var any_of_schemas : Set[str]

The type of the None singleton.

var anyof_schema_1_validator : StringSettings | None

The type of the None singleton.

var anyof_schema_2_validator : IntegerSettings | None

The type of the None singleton.

var anyof_schema_3_validator : OptionSettings | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def actual_instance_must_validate_anyof(v)

def from_dict(obj: Dict[str, Any]) ‑> Self

def from_json(json_str: str) ‑> Self

Returns the object represented by the json string

Methods

def to_dict(self) ‑> Dict[str, Any] | IntegerSettings | OptionSettings | StringSettings | None

Expand source code

def to_dict(self) -> Optional[Union[Dict[str, Any], IntegerSettings, OptionSettings, StringSettings]]:
    """Returns the dict representation of the actual instance"""
    if self.actual_instance is None:
        return None

    if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
        return self.actual_instance.to_dict()
    else:
        return self.actual_instance

Returns the dict representation of the actual instance

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the actual instance"""
    if self.actual_instance is None:
        return "null"

    if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
        return self.actual_instance.to_json()
    else:
        return json.dumps(self.actual_instance)

Returns the JSON representation of the actual instance

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the actual instance"""
    return pprint.pformat(self.model_dump())

Returns the string representation of the actual instance

class Species (**data: Any)

Expand source code

class Species(BaseModel):
    """
    Species
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the species")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Species from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Species from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name")
        })
        return _obj

Species

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Species from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Species from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SpeciesList (**data: Any)

Expand source code

class SpeciesList(BaseModel):
    """
    SpeciesList
    """ # noqa: E501
    items: List[Species]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SpeciesList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SpeciesList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Species.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

SpeciesList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Species]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SpeciesList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SpeciesList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class StorageBundle (**data: Any)

Expand source code

class StorageBundle(BaseModel):
    """
    StorageBundle
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    bundle_name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the storage bundle", alias="bundleName")
    entitlement_name: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The name of the parent entitlement", alias="entitlementName")
    region: Region
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "bundleName", "entitlementName", "region"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of StorageBundle from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of region
        if self.region:
            _dict['region'] = self.region.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of StorageBundle from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "bundleName": obj.get("bundleName"),
            "entitlementName": obj.get("entitlementName"),
            "region": Region.from_dict(obj["region"]) if obj.get("region") is not None else None
        })
        return _obj

StorageBundle

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var bundle_name : str

The type of the None singleton.

var entitlement_name : str

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var region : Region

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of StorageBundle from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of StorageBundle from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of region
    if self.region:
        _dict['region'] = self.region.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class StorageBundleApi (api_client=None)

Expand source code

class StorageBundleApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_storage_bundles(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> StorageBundleList:
        """Retrieve a list of storage bundles.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_bundles_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageBundleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_storage_bundles_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[StorageBundleList]:
        """Retrieve a list of storage bundles.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_bundles_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageBundleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_storage_bundles_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of storage bundles.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_bundles_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageBundleList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_storage_bundles_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/storageBundles',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_storage_bundles(self) ‑> StorageBundleList

Expand source code

@validate_call
def get_storage_bundles(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> StorageBundleList:
    """Retrieve a list of storage bundles.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_bundles_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageBundleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of storage bundles.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_bundles_with_http_info(self) ‑> ApiResponse[StorageBundleList]

Expand source code

@validate_call
def get_storage_bundles_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[StorageBundleList]:
    """Retrieve a list of storage bundles.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_bundles_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageBundleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of storage bundles.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_bundles_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_storage_bundles_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of storage bundles.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_bundles_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageBundleList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of storage bundles.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class StorageBundleList (**data: Any)

Expand source code

class StorageBundleList(BaseModel):
    """
    StorageBundleList
    """ # noqa: E501
    items: List[StorageBundle]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of StorageBundleList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of StorageBundleList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [StorageBundle.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

StorageBundleList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[StorageBundle]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of StorageBundleList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of StorageBundleList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class StorageConfiguration (**data: Any)

Expand source code

class StorageConfiguration(BaseModel):
    """
    StorageConfiguration
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: StrictStr = Field(description="The name of the storage configuration")
    description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=1000)]] = Field(default=None, description="An optional description")
    type: StrictStr
    status: StrictStr
    error_message: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=1000)]] = Field(default=None, description="An optional error message when something went wrong with the configuration", alias="errorMessage")
    region: Region
    is_default: StrictBool = Field(description="An indication if this is the default in region for new projects", alias="isDefault")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "description", "type", "status", "errorMessage", "region", "isDefault"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['AWS_S3']):
            raise ValueError("must be one of enum values ('AWS_S3')")
        return value

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['INITIALIZING', 'OK', 'ERROR']):
            raise ValueError("must be one of enum values ('INITIALIZING', 'OK', 'ERROR')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of StorageConfiguration from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of region
        if self.region:
            _dict['region'] = self.region.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if error_message (nullable) is None
        # and model_fields_set contains the field
        if self.error_message is None and "error_message" in self.model_fields_set:
            _dict['errorMessage'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of StorageConfiguration from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "description": obj.get("description"),
            "type": obj.get("type"),
            "status": obj.get("status"),
            "errorMessage": obj.get("errorMessage"),
            "region": Region.from_dict(obj["region"]) if obj.get("region") is not None else None,
            "isDefault": obj.get("isDefault")
        })
        return _obj

StorageConfiguration

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var error_message : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var is_default : bool

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var region : Region

The type of the None singleton.

var status : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of StorageConfiguration from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of StorageConfiguration from a JSON string

def status_validate_enum(value)

Validates the enum

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of region
    if self.region:
        _dict['region'] = self.region.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if error_message (nullable) is None
    # and model_fields_set contains the field
    if self.error_message is None and "error_message" in self.model_fields_set:
        _dict['errorMessage'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class StorageConfigurationApi (api_client=None)

Expand source code

class StorageConfigurationApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_storage_configuration(
        self,
        create_storage_configuration: CreateStorageConfiguration,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> StorageConfiguration:
        """Create a new storage configuration


        :param create_storage_configuration: (required)
        :type create_storage_configuration: CreateStorageConfiguration
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_storage_configuration_serialize(
            create_storage_configuration=create_storage_configuration,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "StorageConfiguration",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_storage_configuration_with_http_info(
        self,
        create_storage_configuration: CreateStorageConfiguration,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[StorageConfiguration]:
        """Create a new storage configuration


        :param create_storage_configuration: (required)
        :type create_storage_configuration: CreateStorageConfiguration
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_storage_configuration_serialize(
            create_storage_configuration=create_storage_configuration,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "StorageConfiguration",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_storage_configuration_without_preload_content(
        self,
        create_storage_configuration: CreateStorageConfiguration,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a new storage configuration


        :param create_storage_configuration: (required)
        :type create_storage_configuration: CreateStorageConfiguration
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_storage_configuration_serialize(
            create_storage_configuration=create_storage_configuration,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "StorageConfiguration",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_storage_configuration_serialize(
        self,
        create_storage_configuration,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_storage_configuration is not None:
            _body_params = create_storage_configuration


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/storageConfigurations',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_storage_configuration(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> StorageConfiguration:
        """Retrieve a storage configuration.


        :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_configuration_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageConfiguration",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_storage_configuration_with_http_info(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[StorageConfiguration]:
        """Retrieve a storage configuration.


        :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_configuration_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageConfiguration",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_storage_configuration_without_preload_content(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a storage configuration.


        :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_configuration_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageConfiguration",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_storage_configuration_serialize(
        self,
        storage_configuration_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if storage_configuration_id is not None:
            _path_params['storageConfigurationId'] = storage_configuration_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/storageConfigurations/{storageConfigurationId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_storage_configuration_details(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> StorageConfigurationDetails:
        """Retrieve a storage configuration detail.


        :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_configuration_details_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageConfigurationDetails",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_storage_configuration_details_with_http_info(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[StorageConfigurationDetails]:
        """Retrieve a storage configuration detail.


        :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_configuration_details_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageConfigurationDetails",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_storage_configuration_details_without_preload_content(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a storage configuration detail.


        :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_configuration_details_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageConfigurationDetails",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_storage_configuration_details_serialize(
        self,
        storage_configuration_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if storage_configuration_id is not None:
            _path_params['storageConfigurationId'] = storage_configuration_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/storageConfigurations/{storageConfigurationId}/details',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_storage_configurations(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> StorageConfigurationWithDetailsList:
        """Retrieve a list of storage configurations.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_configurations_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageConfigurationWithDetailsList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_storage_configurations_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[StorageConfigurationWithDetailsList]:
        """Retrieve a list of storage configurations.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_configurations_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageConfigurationWithDetailsList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_storage_configurations_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of storage configurations.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_configurations_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageConfigurationWithDetailsList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_storage_configurations_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/storageConfigurations',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def share_storage_configuration(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to share")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Share your own storage configuration with tenant.

        Here you share your own storage configuration with all the other users in your tenant.

        :param storage_configuration_id: The ID of the storage configuration to share (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._share_storage_configuration_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def share_storage_configuration_with_http_info(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to share")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Share your own storage configuration with tenant.

        Here you share your own storage configuration with all the other users in your tenant.

        :param storage_configuration_id: The ID of the storage configuration to share (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._share_storage_configuration_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def share_storage_configuration_without_preload_content(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to share")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Share your own storage configuration with tenant.

        Here you share your own storage configuration with all the other users in your tenant.

        :param storage_configuration_id: The ID of the storage configuration to share (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._share_storage_configuration_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _share_storage_configuration_serialize(
        self,
        storage_configuration_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if storage_configuration_id is not None:
            _path_params['storageConfigurationId'] = storage_configuration_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/storageConfigurations/{storageConfigurationId}:share',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def validate_storage_configuration(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to validate")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Start validation of your storage configuration.

        Here you start the validation of your storage configuration.

        :param storage_configuration_id: The ID of the storage configuration to validate (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._validate_storage_configuration_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def validate_storage_configuration_with_http_info(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to validate")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Start validation of your storage configuration.

        Here you start the validation of your storage configuration.

        :param storage_configuration_id: The ID of the storage configuration to validate (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._validate_storage_configuration_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def validate_storage_configuration_without_preload_content(
        self,
        storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to validate")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Start validation of your storage configuration.

        Here you start the validation of your storage configuration.

        :param storage_configuration_id: The ID of the storage configuration to validate (required)
        :type storage_configuration_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._validate_storage_configuration_serialize(
            storage_configuration_id=storage_configuration_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _validate_storage_configuration_serialize(
        self,
        storage_configuration_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if storage_configuration_id is not None:
            _path_params['storageConfigurationId'] = storage_configuration_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/storageConfigurations/{storageConfigurationId}:validate',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_storage_configuration(self,
create_storage_configuration: CreateStorageConfiguration) ‑> StorageConfiguration

Expand source code

@validate_call
def create_storage_configuration(
    self,
    create_storage_configuration: CreateStorageConfiguration,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> StorageConfiguration:
    """Create a new storage configuration


    :param create_storage_configuration: (required)
    :type create_storage_configuration: CreateStorageConfiguration
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_storage_configuration_serialize(
        create_storage_configuration=create_storage_configuration,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "StorageConfiguration",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a new storage configuration

:param create_storage_configuration: (required) :type create_storage_configuration: CreateStorageConfiguration :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_storage_configuration_with_http_info(self,
create_storage_configuration: CreateStorageConfiguration) ‑> ApiResponse[StorageConfiguration]

Expand source code

@validate_call
def create_storage_configuration_with_http_info(
    self,
    create_storage_configuration: CreateStorageConfiguration,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[StorageConfiguration]:
    """Create a new storage configuration


    :param create_storage_configuration: (required)
    :type create_storage_configuration: CreateStorageConfiguration
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_storage_configuration_serialize(
        create_storage_configuration=create_storage_configuration,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "StorageConfiguration",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a new storage configuration

:param create_storage_configuration: (required) :type create_storage_configuration: CreateStorageConfiguration :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_storage_configuration_without_preload_content(self,
create_storage_configuration: CreateStorageConfiguration) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_storage_configuration_without_preload_content(
    self,
    create_storage_configuration: CreateStorageConfiguration,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a new storage configuration


    :param create_storage_configuration: (required)
    :type create_storage_configuration: CreateStorageConfiguration
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_storage_configuration_serialize(
        create_storage_configuration=create_storage_configuration,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "StorageConfiguration",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a new storage configuration

:param create_storage_configuration: (required) :type create_storage_configuration: CreateStorageConfiguration :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_configuration(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to retrieve')]) ‑> StorageConfiguration

Expand source code

@validate_call
def get_storage_configuration(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> StorageConfiguration:
    """Retrieve a storage configuration.


    :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_configuration_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageConfiguration",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a storage configuration.

:param storage_configuration_id: The ID of the storage configuration to retrieve (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_configuration_details(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to retrieve')]) ‑> StorageConfigurationDetails

Expand source code

@validate_call
def get_storage_configuration_details(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> StorageConfigurationDetails:
    """Retrieve a storage configuration detail.


    :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_configuration_details_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageConfigurationDetails",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a storage configuration detail.

:param storage_configuration_id: The ID of the storage configuration to retrieve (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_configuration_details_with_http_info(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to retrieve')]) ‑> ApiResponse[StorageConfigurationDetails]

Expand source code

@validate_call
def get_storage_configuration_details_with_http_info(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[StorageConfigurationDetails]:
    """Retrieve a storage configuration detail.


    :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_configuration_details_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageConfigurationDetails",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a storage configuration detail.

:param storage_configuration_id: The ID of the storage configuration to retrieve (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_configuration_details_without_preload_content(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_storage_configuration_details_without_preload_content(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a storage configuration detail.


    :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_configuration_details_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageConfigurationDetails",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a storage configuration detail.

:param storage_configuration_id: The ID of the storage configuration to retrieve (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_configuration_with_http_info(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to retrieve')]) ‑> ApiResponse[StorageConfiguration]

Expand source code

@validate_call
def get_storage_configuration_with_http_info(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[StorageConfiguration]:
    """Retrieve a storage configuration.


    :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_configuration_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageConfiguration",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a storage configuration.

:param storage_configuration_id: The ID of the storage configuration to retrieve (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_configuration_without_preload_content(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_storage_configuration_without_preload_content(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a storage configuration.


    :param storage_configuration_id: The ID of the storage configuration to retrieve (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_configuration_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageConfiguration",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a storage configuration.

:param storage_configuration_id: The ID of the storage configuration to retrieve (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_configurations(self) ‑> StorageConfigurationWithDetailsList

Expand source code

@validate_call
def get_storage_configurations(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> StorageConfigurationWithDetailsList:
    """Retrieve a list of storage configurations.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_configurations_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageConfigurationWithDetailsList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of storage configurations.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_configurations_with_http_info(self) ‑> ApiResponse[StorageConfigurationWithDetailsList]

Expand source code

@validate_call
def get_storage_configurations_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[StorageConfigurationWithDetailsList]:
    """Retrieve a list of storage configurations.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_configurations_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageConfigurationWithDetailsList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of storage configurations.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_configurations_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_storage_configurations_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of storage configurations.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_configurations_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageConfigurationWithDetailsList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of storage configurations.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def share_storage_configuration(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to share')]) ‑> None

Expand source code

@validate_call
def share_storage_configuration(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to share")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Share your own storage configuration with tenant.

    Here you share your own storage configuration with all the other users in your tenant.

    :param storage_configuration_id: The ID of the storage configuration to share (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._share_storage_configuration_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Share your own storage configuration with tenant.

Here you share your own storage configuration with all the other users in your tenant.

:param storage_configuration_id: The ID of the storage configuration to share (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def share_storage_configuration_with_http_info(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to share')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def share_storage_configuration_with_http_info(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to share")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Share your own storage configuration with tenant.

    Here you share your own storage configuration with all the other users in your tenant.

    :param storage_configuration_id: The ID of the storage configuration to share (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._share_storage_configuration_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Share your own storage configuration with tenant.

Here you share your own storage configuration with all the other users in your tenant.

:param storage_configuration_id: The ID of the storage configuration to share (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def share_storage_configuration_without_preload_content(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to share')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def share_storage_configuration_without_preload_content(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to share")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Share your own storage configuration with tenant.

    Here you share your own storage configuration with all the other users in your tenant.

    :param storage_configuration_id: The ID of the storage configuration to share (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._share_storage_configuration_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Share your own storage configuration with tenant.

Here you share your own storage configuration with all the other users in your tenant.

:param storage_configuration_id: The ID of the storage configuration to share (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def validate_storage_configuration(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to validate')]) ‑> None

Expand source code

@validate_call
def validate_storage_configuration(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to validate")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Start validation of your storage configuration.

    Here you start the validation of your storage configuration.

    :param storage_configuration_id: The ID of the storage configuration to validate (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._validate_storage_configuration_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Start validation of your storage configuration.

Here you start the validation of your storage configuration.

:param storage_configuration_id: The ID of the storage configuration to validate (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def validate_storage_configuration_with_http_info(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to validate')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def validate_storage_configuration_with_http_info(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to validate")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Start validation of your storage configuration.

    Here you start the validation of your storage configuration.

    :param storage_configuration_id: The ID of the storage configuration to validate (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._validate_storage_configuration_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Start validation of your storage configuration.

Here you start the validation of your storage configuration.

:param storage_configuration_id: The ID of the storage configuration to validate (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def validate_storage_configuration_without_preload_content(self,
storage_configuration_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage libica.openapi.v3.configuration to validate')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def validate_storage_configuration_without_preload_content(
    self,
    storage_configuration_id: Annotated[StrictStr, Field(description="The ID of the storage configuration to validate")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Start validation of your storage configuration.

    Here you start the validation of your storage configuration.

    :param storage_configuration_id: The ID of the storage configuration to validate (required)
    :type storage_configuration_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._validate_storage_configuration_serialize(
        storage_configuration_id=storage_configuration_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Start validation of your storage configuration.

Here you start the validation of your storage configuration.

:param storage_configuration_id: The ID of the storage configuration to validate (required) :type storage_configuration_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class StorageConfigurationDetails (**data: Any)

Expand source code

class StorageConfigurationDetails(BaseModel):
    """
    StorageConfigurationDetails
    """ # noqa: E501
    aws_s3: Optional[AWSDetails] = Field(default=None, alias="awsS3")
    __properties: ClassVar[List[str]] = ["awsS3"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of StorageConfigurationDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of aws_s3
        if self.aws_s3:
            _dict['awsS3'] = self.aws_s3.to_dict()
        # set to None if aws_s3 (nullable) is None
        # and model_fields_set contains the field
        if self.aws_s3 is None and "aws_s3" in self.model_fields_set:
            _dict['awsS3'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of StorageConfigurationDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "awsS3": AWSDetails.from_dict(obj["awsS3"]) if obj.get("awsS3") is not None else None
        })
        return _obj

StorageConfigurationDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var aws_s3 : AWSDetails | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of StorageConfigurationDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of StorageConfigurationDetails from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of aws_s3
    if self.aws_s3:
        _dict['awsS3'] = self.aws_s3.to_dict()
    # set to None if aws_s3 (nullable) is None
    # and model_fields_set contains the field
    if self.aws_s3 is None and "aws_s3" in self.model_fields_set:
        _dict['awsS3'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class StorageConfigurationWithDetails (**data: Any)

Expand source code

class StorageConfigurationWithDetails(BaseModel):
    """
    StorageConfigurationWithDetails
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: StrictStr = Field(description="The name of the storage configuration")
    description: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=1000)]] = Field(default=None, description="An optional description")
    type: StrictStr
    status: StrictStr
    error_message: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=1000)]] = Field(default=None, description="An optional error message when something went wrong with the configuration", alias="errorMessage")
    region: Region
    is_default: StrictBool = Field(description="An indication if this is the default in region for new projects", alias="isDefault")
    storage_configuration_details: StorageConfigurationDetails = Field(alias="storageConfigurationDetails")
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "description", "type", "status", "errorMessage", "region", "isDefault", "storageConfigurationDetails"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['AWS_S3']):
            raise ValueError("must be one of enum values ('AWS_S3')")
        return value

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['INITIALIZING', 'OK', 'ERROR']):
            raise ValueError("must be one of enum values ('INITIALIZING', 'OK', 'ERROR')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of StorageConfigurationWithDetails from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of region
        if self.region:
            _dict['region'] = self.region.to_dict()
        # override the default output from pydantic by calling `to_dict()` of storage_configuration_details
        if self.storage_configuration_details:
            _dict['storageConfigurationDetails'] = self.storage_configuration_details.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if error_message (nullable) is None
        # and model_fields_set contains the field
        if self.error_message is None and "error_message" in self.model_fields_set:
            _dict['errorMessage'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of StorageConfigurationWithDetails from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "description": obj.get("description"),
            "type": obj.get("type"),
            "status": obj.get("status"),
            "errorMessage": obj.get("errorMessage"),
            "region": Region.from_dict(obj["region"]) if obj.get("region") is not None else None,
            "isDefault": obj.get("isDefault"),
            "storageConfigurationDetails": StorageConfigurationDetails.from_dict(obj["storageConfigurationDetails"]) if obj.get("storageConfigurationDetails") is not None else None
        })
        return _obj

StorageConfigurationWithDetails

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str | None

The type of the None singleton.

var error_message : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var is_default : bool

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var region : Region

The type of the None singleton.

var status : str

The type of the None singleton.

var storage_configuration_details : StorageConfigurationDetails

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of StorageConfigurationWithDetails from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of StorageConfigurationWithDetails from a JSON string

def status_validate_enum(value)

Validates the enum

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of region
    if self.region:
        _dict['region'] = self.region.to_dict()
    # override the default output from pydantic by calling `to_dict()` of storage_configuration_details
    if self.storage_configuration_details:
        _dict['storageConfigurationDetails'] = self.storage_configuration_details.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if error_message (nullable) is None
    # and model_fields_set contains the field
    if self.error_message is None and "error_message" in self.model_fields_set:
        _dict['errorMessage'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class StorageConfigurationWithDetailsList (**data: Any)

Expand source code

class StorageConfigurationWithDetailsList(BaseModel):
    """
    StorageConfigurationWithDetailsList
    """ # noqa: E501
    items: List[StorageConfigurationWithDetails]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of StorageConfigurationWithDetailsList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of StorageConfigurationWithDetailsList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [StorageConfigurationWithDetails.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

StorageConfigurationWithDetailsList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[StorageConfigurationWithDetails]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of StorageConfigurationWithDetailsList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of StorageConfigurationWithDetailsList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class StorageCredential (**data: Any)

Expand source code

class StorageCredential(BaseModel):
    """
    StorageCredential
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    name: Annotated[str, Field(min_length=1, strict=True, max_length=150)]
    type: StrictStr
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "name", "type"]

    @field_validator('type')
    def type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['AWS_USER']):
            raise ValueError("must be one of enum values ('AWS_USER')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of StorageCredential from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of StorageCredential from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "name": obj.get("name"),
            "type": obj.get("type")
        })
        return _obj

StorageCredential

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var type : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of StorageCredential from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of StorageCredential from a JSON string

def type_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class StorageCredentialList (**data: Any)

Expand source code

class StorageCredentialList(BaseModel):
    """
    StorageCredentialList
    """ # noqa: E501
    items: List[StorageCredential]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of StorageCredentialList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of StorageCredentialList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [StorageCredential.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

StorageCredentialList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[StorageCredential]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of StorageCredentialList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of StorageCredentialList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class StorageCredentialsApi (api_client=None)

Expand source code

class StorageCredentialsApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_storage_credential(
        self,
        create_storage_credential: CreateStorageCredential,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> StorageCredential:
        """Create a new storage credential


        :param create_storage_credential: (required)
        :type create_storage_credential: CreateStorageCredential
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_storage_credential_serialize(
            create_storage_credential=create_storage_credential,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "StorageCredential",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_storage_credential_with_http_info(
        self,
        create_storage_credential: CreateStorageCredential,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[StorageCredential]:
        """Create a new storage credential


        :param create_storage_credential: (required)
        :type create_storage_credential: CreateStorageCredential
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_storage_credential_serialize(
            create_storage_credential=create_storage_credential,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "StorageCredential",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_storage_credential_without_preload_content(
        self,
        create_storage_credential: CreateStorageCredential,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Create a new storage credential


        :param create_storage_credential: (required)
        :type create_storage_credential: CreateStorageCredential
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_storage_credential_serialize(
            create_storage_credential=create_storage_credential,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '201': "StorageCredential",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_storage_credential_serialize(
        self,
        create_storage_credential,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if create_storage_credential is not None:
            _body_params = create_storage_credential


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/storageCredentials',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_storage_credential(
        self,
        storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> StorageCredential:
        """Retrieve a storage credential.


        :param storage_credential_id: The ID of the storage credential to retrieve (required)
        :type storage_credential_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_credential_serialize(
            storage_credential_id=storage_credential_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageCredential",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_storage_credential_with_http_info(
        self,
        storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[StorageCredential]:
        """Retrieve a storage credential.


        :param storage_credential_id: The ID of the storage credential to retrieve (required)
        :type storage_credential_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_credential_serialize(
            storage_credential_id=storage_credential_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageCredential",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_storage_credential_without_preload_content(
        self,
        storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a storage credential.


        :param storage_credential_id: The ID of the storage credential to retrieve (required)
        :type storage_credential_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_credential_serialize(
            storage_credential_id=storage_credential_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageCredential",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_storage_credential_serialize(
        self,
        storage_credential_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if storage_credential_id is not None:
            _path_params['storageCredentialId'] = storage_credential_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/storageCredentials/{storageCredentialId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_storage_credentials(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> StorageCredentialList:
        """Retrieve a list of storage credentials.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_credentials_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageCredentialList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_storage_credentials_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[StorageCredentialList]:
        """Retrieve a list of storage credentials.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_credentials_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageCredentialList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_storage_credentials_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of storage credentials.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_storage_credentials_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "StorageCredentialList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_storage_credentials_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/storageCredentials',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def share_storage_credential(
        self,
        storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to share")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Share your own storage credentials with tenant.

        Here you share your own storage credentials with all the other users in your tenant.

        :param storage_credential_id: The ID of the storage credential to share (required)
        :type storage_credential_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._share_storage_credential_serialize(
            storage_credential_id=storage_credential_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def share_storage_credential_with_http_info(
        self,
        storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to share")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Share your own storage credentials with tenant.

        Here you share your own storage credentials with all the other users in your tenant.

        :param storage_credential_id: The ID of the storage credential to share (required)
        :type storage_credential_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._share_storage_credential_serialize(
            storage_credential_id=storage_credential_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def share_storage_credential_without_preload_content(
        self,
        storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to share")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Share your own storage credentials with tenant.

        Here you share your own storage credentials with all the other users in your tenant.

        :param storage_credential_id: The ID of the storage credential to share (required)
        :type storage_credential_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._share_storage_credential_serialize(
            storage_credential_id=storage_credential_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _share_storage_credential_serialize(
        self,
        storage_credential_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if storage_credential_id is not None:
            _path_params['storageCredentialId'] = storage_credential_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/storageCredentials/{storageCredentialId}:share',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_storage_credential_secrets(
        self,
        storage_credential_id: StrictStr,
        update_storage_credential_secrets: UpdateStorageCredentialSecrets,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Update a storage credential's secrets.

        When your storage credentials change or get updated due to security reasons you need to update them here.

        :param storage_credential_id: (required)
        :type storage_credential_id: str
        :param update_storage_credential_secrets: (required)
        :type update_storage_credential_secrets: UpdateStorageCredentialSecrets
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_storage_credential_secrets_serialize(
            storage_credential_id=storage_credential_id,
            update_storage_credential_secrets=update_storage_credential_secrets,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_storage_credential_secrets_with_http_info(
        self,
        storage_credential_id: StrictStr,
        update_storage_credential_secrets: UpdateStorageCredentialSecrets,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Update a storage credential's secrets.

        When your storage credentials change or get updated due to security reasons you need to update them here.

        :param storage_credential_id: (required)
        :type storage_credential_id: str
        :param update_storage_credential_secrets: (required)
        :type update_storage_credential_secrets: UpdateStorageCredentialSecrets
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_storage_credential_secrets_serialize(
            storage_credential_id=storage_credential_id,
            update_storage_credential_secrets=update_storage_credential_secrets,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_storage_credential_secrets_without_preload_content(
        self,
        storage_credential_id: StrictStr,
        update_storage_credential_secrets: UpdateStorageCredentialSecrets,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a storage credential's secrets.

        When your storage credentials change or get updated due to security reasons you need to update them here.

        :param storage_credential_id: (required)
        :type storage_credential_id: str
        :param update_storage_credential_secrets: (required)
        :type update_storage_credential_secrets: UpdateStorageCredentialSecrets
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_storage_credential_secrets_serialize(
            storage_credential_id=storage_credential_id,
            update_storage_credential_secrets=update_storage_credential_secrets,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_storage_credential_secrets_serialize(
        self,
        storage_credential_id,
        update_storage_credential_secrets,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if storage_credential_id is not None:
            _path_params['storageCredentialId'] = storage_credential_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter
        if update_storage_credential_secrets is not None:
            _body_params = update_storage_credential_secrets


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/storageCredentials/{storageCredentialId}:updateSecrets',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_storage_credential(self,
create_storage_credential: CreateStorageCredential) ‑> StorageCredential

Expand source code

@validate_call
def create_storage_credential(
    self,
    create_storage_credential: CreateStorageCredential,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> StorageCredential:
    """Create a new storage credential


    :param create_storage_credential: (required)
    :type create_storage_credential: CreateStorageCredential
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_storage_credential_serialize(
        create_storage_credential=create_storage_credential,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "StorageCredential",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Create a new storage credential

:param create_storage_credential: (required) :type create_storage_credential: CreateStorageCredential :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_storage_credential_with_http_info(self,
create_storage_credential: CreateStorageCredential) ‑> ApiResponse[StorageCredential]

Expand source code

@validate_call
def create_storage_credential_with_http_info(
    self,
    create_storage_credential: CreateStorageCredential,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[StorageCredential]:
    """Create a new storage credential


    :param create_storage_credential: (required)
    :type create_storage_credential: CreateStorageCredential
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_storage_credential_serialize(
        create_storage_credential=create_storage_credential,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "StorageCredential",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Create a new storage credential

:param create_storage_credential: (required) :type create_storage_credential: CreateStorageCredential :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_storage_credential_without_preload_content(self,
create_storage_credential: CreateStorageCredential) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_storage_credential_without_preload_content(
    self,
    create_storage_credential: CreateStorageCredential,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Create a new storage credential


    :param create_storage_credential: (required)
    :type create_storage_credential: CreateStorageCredential
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_storage_credential_serialize(
        create_storage_credential=create_storage_credential,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '201': "StorageCredential",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Create a new storage credential

:param create_storage_credential: (required) :type create_storage_credential: CreateStorageCredential :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_credential(self,
storage_credential_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage credential to retrieve')]) ‑> StorageCredential

Expand source code

@validate_call
def get_storage_credential(
    self,
    storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> StorageCredential:
    """Retrieve a storage credential.


    :param storage_credential_id: The ID of the storage credential to retrieve (required)
    :type storage_credential_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_credential_serialize(
        storage_credential_id=storage_credential_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageCredential",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a storage credential.

:param storage_credential_id: The ID of the storage credential to retrieve (required) :type storage_credential_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_credential_with_http_info(self,
storage_credential_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage credential to retrieve')]) ‑> ApiResponse[StorageCredential]

Expand source code

@validate_call
def get_storage_credential_with_http_info(
    self,
    storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[StorageCredential]:
    """Retrieve a storage credential.


    :param storage_credential_id: The ID of the storage credential to retrieve (required)
    :type storage_credential_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_credential_serialize(
        storage_credential_id=storage_credential_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageCredential",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a storage credential.

:param storage_credential_id: The ID of the storage credential to retrieve (required) :type storage_credential_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_credential_without_preload_content(self,
storage_credential_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage credential to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_storage_credential_without_preload_content(
    self,
    storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a storage credential.


    :param storage_credential_id: The ID of the storage credential to retrieve (required)
    :type storage_credential_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_credential_serialize(
        storage_credential_id=storage_credential_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageCredential",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a storage credential.

:param storage_credential_id: The ID of the storage credential to retrieve (required) :type storage_credential_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_credentials(self) ‑> StorageCredentialList

Expand source code

@validate_call
def get_storage_credentials(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> StorageCredentialList:
    """Retrieve a list of storage credentials.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_credentials_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageCredentialList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of storage credentials.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_credentials_with_http_info(self) ‑> ApiResponse[StorageCredentialList]

Expand source code

@validate_call
def get_storage_credentials_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[StorageCredentialList]:
    """Retrieve a list of storage credentials.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_credentials_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageCredentialList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of storage credentials.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_storage_credentials_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_storage_credentials_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of storage credentials.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_storage_credentials_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "StorageCredentialList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of storage credentials.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def share_storage_credential(self,
storage_credential_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage credential to share')]) ‑> None

Expand source code

@validate_call
def share_storage_credential(
    self,
    storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to share")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Share your own storage credentials with tenant.

    Here you share your own storage credentials with all the other users in your tenant.

    :param storage_credential_id: The ID of the storage credential to share (required)
    :type storage_credential_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._share_storage_credential_serialize(
        storage_credential_id=storage_credential_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Share your own storage credentials with tenant.

Here you share your own storage credentials with all the other users in your tenant.

:param storage_credential_id: The ID of the storage credential to share (required) :type storage_credential_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def share_storage_credential_with_http_info(self,
storage_credential_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage credential to share')]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def share_storage_credential_with_http_info(
    self,
    storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to share")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Share your own storage credentials with tenant.

    Here you share your own storage credentials with all the other users in your tenant.

    :param storage_credential_id: The ID of the storage credential to share (required)
    :type storage_credential_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._share_storage_credential_serialize(
        storage_credential_id=storage_credential_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Share your own storage credentials with tenant.

Here you share your own storage credentials with all the other users in your tenant.

:param storage_credential_id: The ID of the storage credential to share (required) :type storage_credential_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def share_storage_credential_without_preload_content(self,
storage_credential_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the storage credential to share')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def share_storage_credential_without_preload_content(
    self,
    storage_credential_id: Annotated[StrictStr, Field(description="The ID of the storage credential to share")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Share your own storage credentials with tenant.

    Here you share your own storage credentials with all the other users in your tenant.

    :param storage_credential_id: The ID of the storage credential to share (required)
    :type storage_credential_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._share_storage_credential_serialize(
        storage_credential_id=storage_credential_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Share your own storage credentials with tenant.

Here you share your own storage credentials with all the other users in your tenant.

:param storage_credential_id: The ID of the storage credential to share (required) :type storage_credential_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_storage_credential_secrets(self,
storage_credential_id: Annotated[str, Strict(strict=True)],
update_storage_credential_secrets: UpdateStorageCredentialSecrets) ‑> None

Expand source code

@validate_call
def update_storage_credential_secrets(
    self,
    storage_credential_id: StrictStr,
    update_storage_credential_secrets: UpdateStorageCredentialSecrets,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Update a storage credential's secrets.

    When your storage credentials change or get updated due to security reasons you need to update them here.

    :param storage_credential_id: (required)
    :type storage_credential_id: str
    :param update_storage_credential_secrets: (required)
    :type update_storage_credential_secrets: UpdateStorageCredentialSecrets
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_storage_credential_secrets_serialize(
        storage_credential_id=storage_credential_id,
        update_storage_credential_secrets=update_storage_credential_secrets,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update a storage credential's secrets.

When your storage credentials change or get updated due to security reasons you need to update them here.

:param storage_credential_id: (required) :type storage_credential_id: str :param update_storage_credential_secrets: (required) :type update_storage_credential_secrets: UpdateStorageCredentialSecrets :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_storage_credential_secrets_with_http_info(self,
storage_credential_id: Annotated[str, Strict(strict=True)],
update_storage_credential_secrets: UpdateStorageCredentialSecrets) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def update_storage_credential_secrets_with_http_info(
    self,
    storage_credential_id: StrictStr,
    update_storage_credential_secrets: UpdateStorageCredentialSecrets,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Update a storage credential's secrets.

    When your storage credentials change or get updated due to security reasons you need to update them here.

    :param storage_credential_id: (required)
    :type storage_credential_id: str
    :param update_storage_credential_secrets: (required)
    :type update_storage_credential_secrets: UpdateStorageCredentialSecrets
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_storage_credential_secrets_serialize(
        storage_credential_id=storage_credential_id,
        update_storage_credential_secrets=update_storage_credential_secrets,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update a storage credential's secrets.

When your storage credentials change or get updated due to security reasons you need to update them here.

:param storage_credential_id: (required) :type storage_credential_id: str :param update_storage_credential_secrets: (required) :type update_storage_credential_secrets: UpdateStorageCredentialSecrets :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_storage_credential_secrets_without_preload_content(self,
storage_credential_id: Annotated[str, Strict(strict=True)],
update_storage_credential_secrets: UpdateStorageCredentialSecrets) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_storage_credential_secrets_without_preload_content(
    self,
    storage_credential_id: StrictStr,
    update_storage_credential_secrets: UpdateStorageCredentialSecrets,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update a storage credential's secrets.

    When your storage credentials change or get updated due to security reasons you need to update them here.

    :param storage_credential_id: (required)
    :type storage_credential_id: str
    :param update_storage_credential_secrets: (required)
    :type update_storage_credential_secrets: UpdateStorageCredentialSecrets
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_storage_credential_secrets_serialize(
        storage_credential_id=storage_credential_id,
        update_storage_credential_secrets=update_storage_credential_secrets,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update a storage credential's secrets.

When your storage credentials change or get updated due to security reasons you need to update them here.

:param storage_credential_id: (required) :type storage_credential_id: str :param update_storage_credential_secrets: (required) :type update_storage_credential_secrets: UpdateStorageCredentialSecrets :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class StringSettings (**data: Any)

Expand source code

class StringSettings(BaseModel):
    """
    StringSettings
    """ # noqa: E501
    default_values: Optional[List[StrictStr]] = Field(default=None, alias="defaultValues")
    __properties: ClassVar[List[str]] = ["defaultValues"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of StringSettings from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of StringSettings from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "defaultValues": obj.get("defaultValues")
        })
        return _obj

StringSettings

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var default_values : List[str] | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of StringSettings from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of StringSettings from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class SystemApi (api_client=None)

Expand source code

class SystemApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_system_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> SystemInfo:
        """Retrieve system information.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_system_info_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SystemInfo",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_system_info_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[SystemInfo]:
        """Retrieve system information.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_system_info_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SystemInfo",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_system_info_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve system information.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_system_info_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "SystemInfo",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_system_info_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/system/info',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_system_info(self) ‑> SystemInfo

Expand source code

@validate_call
def get_system_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> SystemInfo:
    """Retrieve system information.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_system_info_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SystemInfo",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve system information.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_system_info_with_http_info(self) ‑> ApiResponse[SystemInfo]

Expand source code

@validate_call
def get_system_info_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[SystemInfo]:
    """Retrieve system information.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_system_info_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SystemInfo",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve system information.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_system_info_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_system_info_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve system information.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_system_info_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "SystemInfo",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve system information.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class SystemInfo (**data: Any)

Expand source code

class SystemInfo(BaseModel):
    """
    SystemInfo
    """ # noqa: E501
    name: StrictStr
    version: StrictStr
    __properties: ClassVar[List[str]] = ["name", "version"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of SystemInfo from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of SystemInfo from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "version": obj.get("version")
        })
        return _obj

SystemInfo

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

var version : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of SystemInfo from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of SystemInfo from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class TagUpdate (**data: Any)

Expand source code

class TagUpdate(BaseModel):
    """
    TagUpdate
    """ # noqa: E501
    add_tags: Optional[List[StrictStr]] = Field(default=None, alias="addTags")
    remove_tags: Optional[List[StrictStr]] = Field(default=None, alias="removeTags")
    __properties: ClassVar[List[str]] = ["addTags", "removeTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of TagUpdate from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of TagUpdate from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "addTags": obj.get("addTags"),
            "removeTags": obj.get("removeTags")
        })
        return _obj

TagUpdate

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var add_tags : List[str] | None

The type of the None singleton.

var model_config

The type of the None singleton.

var remove_tags : List[str] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of TagUpdate from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of TagUpdate from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class TempCredentials (**data: Any)

Expand source code

class TempCredentials(BaseModel):
    """
    TempCredentials
    """ # noqa: E501
    aws_temp_credentials: Optional[AwsTempCredentials] = Field(default=None, alias="awsTempCredentials")
    rclone_temp_credentials: Optional[RcloneTempCredentials] = Field(default=None, alias="rcloneTempCredentials")
    __properties: ClassVar[List[str]] = ["awsTempCredentials", "rcloneTempCredentials"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of TempCredentials from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of aws_temp_credentials
        if self.aws_temp_credentials:
            _dict['awsTempCredentials'] = self.aws_temp_credentials.to_dict()
        # override the default output from pydantic by calling `to_dict()` of rclone_temp_credentials
        if self.rclone_temp_credentials:
            _dict['rcloneTempCredentials'] = self.rclone_temp_credentials.to_dict()
        # set to None if aws_temp_credentials (nullable) is None
        # and model_fields_set contains the field
        if self.aws_temp_credentials is None and "aws_temp_credentials" in self.model_fields_set:
            _dict['awsTempCredentials'] = None

        # set to None if rclone_temp_credentials (nullable) is None
        # and model_fields_set contains the field
        if self.rclone_temp_credentials is None and "rclone_temp_credentials" in self.model_fields_set:
            _dict['rcloneTempCredentials'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of TempCredentials from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "awsTempCredentials": AwsTempCredentials.from_dict(obj["awsTempCredentials"]) if obj.get("awsTempCredentials") is not None else None,
            "rcloneTempCredentials": RcloneTempCredentials.from_dict(obj["rcloneTempCredentials"]) if obj.get("rcloneTempCredentials") is not None else None
        })
        return _obj

TempCredentials

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var aws_temp_credentials : AwsTempCredentials | None

The type of the None singleton.

var model_config

The type of the None singleton.

var rclone_temp_credentials : RcloneTempCredentials | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of TempCredentials from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of TempCredentials from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of aws_temp_credentials
    if self.aws_temp_credentials:
        _dict['awsTempCredentials'] = self.aws_temp_credentials.to_dict()
    # override the default output from pydantic by calling `to_dict()` of rclone_temp_credentials
    if self.rclone_temp_credentials:
        _dict['rcloneTempCredentials'] = self.rclone_temp_credentials.to_dict()
    # set to None if aws_temp_credentials (nullable) is None
    # and model_fields_set contains the field
    if self.aws_temp_credentials is None and "aws_temp_credentials" in self.model_fields_set:
        _dict['awsTempCredentials'] = None

    # set to None if rclone_temp_credentials (nullable) is None
    # and model_fields_set contains the field
    if self.rclone_temp_credentials is None and "rclone_temp_credentials" in self.model_fields_set:
        _dict['rcloneTempCredentials'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class TenantIdentifier (**data: Any)

Expand source code

class TenantIdentifier(BaseModel):
    """
    TenantIdentifier
    """ # noqa: E501
    id: StrictStr
    name: Optional[StrictStr] = Field(default=None, description="The unique name of the tenant.")
    __properties: ClassVar[List[str]] = ["id", "name"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of TenantIdentifier from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of TenantIdentifier from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name")
        })
        return _obj

TenantIdentifier

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of TenantIdentifier from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of TenantIdentifier from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class TermsOfUse (**data: Any)

Expand source code

class TermsOfUse(BaseModel):
    """
    TermsOfUse
    """ # noqa: E501
    terms_of_use: StrictStr = Field(description="Terms of Use for a bundle. Supports plain text or HTML.", alias="termsOfUse")
    requires_user_acceptance: StrictBool = Field(description="Flag indicating whether the Terms of Use should be accepted before using/viewing the bundle.", alias="requiresUserAcceptance")
    release_version: Optional[StrictStr] = Field(default=None, description="Version number of the Terms of Use.", alias="releaseVersion")
    __properties: ClassVar[List[str]] = ["termsOfUse", "requiresUserAcceptance", "releaseVersion"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of TermsOfUse from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of TermsOfUse from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "termsOfUse": obj.get("termsOfUse"),
            "requiresUserAcceptance": obj.get("requiresUserAcceptance"),
            "releaseVersion": obj.get("releaseVersion")
        })
        return _obj

TermsOfUse

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var release_version : str | None

The type of the None singleton.

var requires_user_acceptance : bool

The type of the None singleton.

var terms_of_use : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of TermsOfUse from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of TermsOfUse from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class TermsOfUseAcceptance (**data: Any)

Expand source code

class TermsOfUseAcceptance(BaseModel):
    """
    TermsOfUseAcceptance
    """ # noqa: E501
    accepted: StrictBool = Field(description="Are the terms of use accepted")
    first_acceptance_date: datetime = Field(description="Date of the first time the terms of use were accepted.", alias="firstAcceptanceDate")
    version_terms_of_use_first_accept: StrictStr = Field(description="Version of the first accepted Terms of Use.", alias="versionTermsOfUseFirstAccept")
    last_acceptance_date: Optional[datetime] = Field(default=None, description="Date of the last time the terms of use were accepted.", alias="lastAcceptanceDate")
    version_terms_of_use_last_accept: Optional[StrictStr] = Field(default=None, description="Version of the last accepted Terms of Use.", alias="versionTermsOfUseLastAccept")
    __properties: ClassVar[List[str]] = ["accepted", "firstAcceptanceDate", "versionTermsOfUseFirstAccept", "lastAcceptanceDate", "versionTermsOfUseLastAccept"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of TermsOfUseAcceptance from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of TermsOfUseAcceptance from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "accepted": obj.get("accepted"),
            "firstAcceptanceDate": obj.get("firstAcceptanceDate"),
            "versionTermsOfUseFirstAccept": obj.get("versionTermsOfUseFirstAccept"),
            "lastAcceptanceDate": obj.get("lastAcceptanceDate"),
            "versionTermsOfUseLastAccept": obj.get("versionTermsOfUseLastAccept")
        })
        return _obj

TermsOfUseAcceptance

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var accepted : bool

The type of the None singleton.

var first_acceptance_date : datetime.datetime

The type of the None singleton.

var last_acceptance_date : datetime.datetime | None

The type of the None singleton.

var model_config

The type of the None singleton.

var version_terms_of_use_first_accept : str

The type of the None singleton.

var version_terms_of_use_last_accept : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of TermsOfUseAcceptance from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of TermsOfUseAcceptance from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Token (**data: Any)

Expand source code

class Token(BaseModel):
    """
    Token
    """ # noqa: E501
    token: Optional[StrictStr] = None
    __properties: ClassVar[List[str]] = ["token"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Token from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Token from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "token": obj.get("token")
        })
        return _obj

Token

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var token : str | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Token from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Token from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class TokenApi (api_client=None)

Expand source code

class TokenApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def create_jwt_token(
        self,
        tenant: Annotated[Optional[StrictStr], Field(description="The name of your tenant in case you have access to multiple tenants.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Token:
        """Generate a JWT using an API-key, Basic Authentication or a psToken.

        Generate a JWT using an API-key, Basic Authentication or a psToken. When using Basic Authentication, and you are member of several tenants, also provide the tenant request parameter to indicate for which tenant you want to authenticate. Note that Basic Authentication will not work for SSO (Single Sign On) enabled authentication.

        :param tenant: The name of your tenant in case you have access to multiple tenants.
        :type tenant: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_jwt_token_serialize(
            tenant=tenant,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Token",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def create_jwt_token_with_http_info(
        self,
        tenant: Annotated[Optional[StrictStr], Field(description="The name of your tenant in case you have access to multiple tenants.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Token]:
        """Generate a JWT using an API-key, Basic Authentication or a psToken.

        Generate a JWT using an API-key, Basic Authentication or a psToken. When using Basic Authentication, and you are member of several tenants, also provide the tenant request parameter to indicate for which tenant you want to authenticate. Note that Basic Authentication will not work for SSO (Single Sign On) enabled authentication.

        :param tenant: The name of your tenant in case you have access to multiple tenants.
        :type tenant: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_jwt_token_serialize(
            tenant=tenant,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Token",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def create_jwt_token_without_preload_content(
        self,
        tenant: Annotated[Optional[StrictStr], Field(description="The name of your tenant in case you have access to multiple tenants.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Generate a JWT using an API-key, Basic Authentication or a psToken.

        Generate a JWT using an API-key, Basic Authentication or a psToken. When using Basic Authentication, and you are member of several tenants, also provide the tenant request parameter to indicate for which tenant you want to authenticate. Note that Basic Authentication will not work for SSO (Single Sign On) enabled authentication.

        :param tenant: The name of your tenant in case you have access to multiple tenants.
        :type tenant: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._create_jwt_token_serialize(
            tenant=tenant,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Token",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _create_jwt_token_serialize(
        self,
        tenant,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if tenant is not None:
            
            _query_params.append(('tenant', tenant))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'PsTokenAuth', 
            'BasicAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/tokens',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def refresh_jwt_token(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Token:
        """Refresh a JWT using a not yet expired, still valid JWT.

        When still having a valid JWT, this endpoint can be used to extend the validity.<br>Refreshing the JWT is not possible if it has been created using an API-key.

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._refresh_jwt_token_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Token",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def refresh_jwt_token_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Token]:
        """Refresh a JWT using a not yet expired, still valid JWT.

        When still having a valid JWT, this endpoint can be used to extend the validity.<br>Refreshing the JWT is not possible if it has been created using an API-key.

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._refresh_jwt_token_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Token",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def refresh_jwt_token_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Refresh a JWT using a not yet expired, still valid JWT.

        When still having a valid JWT, this endpoint can be used to extend the validity.<br>Refreshing the JWT is not possible if it has been created using an API-key.

        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._refresh_jwt_token_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Token",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _refresh_jwt_token_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/tokens:refresh',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def create_jwt_token(self,
tenant: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The name of your tenant in case you have access to multiple tenants.')] = None) ‑> Token

Expand source code

@validate_call
def create_jwt_token(
    self,
    tenant: Annotated[Optional[StrictStr], Field(description="The name of your tenant in case you have access to multiple tenants.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Token:
    """Generate a JWT using an API-key, Basic Authentication or a psToken.

    Generate a JWT using an API-key, Basic Authentication or a psToken. When using Basic Authentication, and you are member of several tenants, also provide the tenant request parameter to indicate for which tenant you want to authenticate. Note that Basic Authentication will not work for SSO (Single Sign On) enabled authentication.

    :param tenant: The name of your tenant in case you have access to multiple tenants.
    :type tenant: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_jwt_token_serialize(
        tenant=tenant,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Token",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Generate a JWT using an API-key, Basic Authentication or a psToken.

Generate a JWT using an API-key, Basic Authentication or a psToken. When using Basic Authentication, and you are member of several tenants, also provide the tenant request parameter to indicate for which tenant you want to authenticate. Note that Basic Authentication will not work for SSO (Single Sign On) enabled authentication.

:param tenant: The name of your tenant in case you have access to multiple tenants. :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_jwt_token_with_http_info(self,
tenant: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The name of your tenant in case you have access to multiple tenants.')] = None) ‑> ApiResponse[Token]

Expand source code

@validate_call
def create_jwt_token_with_http_info(
    self,
    tenant: Annotated[Optional[StrictStr], Field(description="The name of your tenant in case you have access to multiple tenants.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Token]:
    """Generate a JWT using an API-key, Basic Authentication or a psToken.

    Generate a JWT using an API-key, Basic Authentication or a psToken. When using Basic Authentication, and you are member of several tenants, also provide the tenant request parameter to indicate for which tenant you want to authenticate. Note that Basic Authentication will not work for SSO (Single Sign On) enabled authentication.

    :param tenant: The name of your tenant in case you have access to multiple tenants.
    :type tenant: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_jwt_token_serialize(
        tenant=tenant,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Token",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Generate a JWT using an API-key, Basic Authentication or a psToken.

Generate a JWT using an API-key, Basic Authentication or a psToken. When using Basic Authentication, and you are member of several tenants, also provide the tenant request parameter to indicate for which tenant you want to authenticate. Note that Basic Authentication will not work for SSO (Single Sign On) enabled authentication.

:param tenant: The name of your tenant in case you have access to multiple tenants. :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def create_jwt_token_without_preload_content(self,
tenant: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The name of your tenant in case you have access to multiple tenants.')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def create_jwt_token_without_preload_content(
    self,
    tenant: Annotated[Optional[StrictStr], Field(description="The name of your tenant in case you have access to multiple tenants.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Generate a JWT using an API-key, Basic Authentication or a psToken.

    Generate a JWT using an API-key, Basic Authentication or a psToken. When using Basic Authentication, and you are member of several tenants, also provide the tenant request parameter to indicate for which tenant you want to authenticate. Note that Basic Authentication will not work for SSO (Single Sign On) enabled authentication.

    :param tenant: The name of your tenant in case you have access to multiple tenants.
    :type tenant: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._create_jwt_token_serialize(
        tenant=tenant,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Token",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Generate a JWT using an API-key, Basic Authentication or a psToken.

Generate a JWT using an API-key, Basic Authentication or a psToken. When using Basic Authentication, and you are member of several tenants, also provide the tenant request parameter to indicate for which tenant you want to authenticate. Note that Basic Authentication will not work for SSO (Single Sign On) enabled authentication.

:param tenant: The name of your tenant in case you have access to multiple tenants. :type tenant: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def refresh_jwt_token(self) ‑> Token

Expand source code

@validate_call
def refresh_jwt_token(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Token:
    """Refresh a JWT using a not yet expired, still valid JWT.

    When still having a valid JWT, this endpoint can be used to extend the validity.<br>Refreshing the JWT is not possible if it has been created using an API-key.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._refresh_jwt_token_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Token",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Refresh a JWT using a not yet expired, still valid JWT.

When still having a valid JWT, this endpoint can be used to extend the validity.
Refreshing the JWT is not possible if it has been created using an API-key.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def refresh_jwt_token_with_http_info(self) ‑> ApiResponse[Token]

Expand source code

@validate_call
def refresh_jwt_token_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Token]:
    """Refresh a JWT using a not yet expired, still valid JWT.

    When still having a valid JWT, this endpoint can be used to extend the validity.<br>Refreshing the JWT is not possible if it has been created using an API-key.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._refresh_jwt_token_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Token",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Refresh a JWT using a not yet expired, still valid JWT.

When still having a valid JWT, this endpoint can be used to extend the validity.
Refreshing the JWT is not possible if it has been created using an API-key.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def refresh_jwt_token_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def refresh_jwt_token_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Refresh a JWT using a not yet expired, still valid JWT.

    When still having a valid JWT, this endpoint can be used to extend the validity.<br>Refreshing the JWT is not possible if it has been created using an API-key.

    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._refresh_jwt_token_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Token",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Refresh a JWT using a not yet expired, still valid JWT.

When still having a valid JWT, this endpoint can be used to extend the validity.
Refreshing the JWT is not possible if it has been created using an API-key.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class UpdateMetadata (**data: Any)

Expand source code

class UpdateMetadata(BaseModel):
    """
    UpdateMetadata
    """ # noqa: E501
    update_single_metadata_fields: Optional[List[UpdateSingleMetadataField]] = Field(default=None, description="List of metadata fields to be updated", alias="updateSingleMetadataFields")
    update_metadata_field_groups: Optional[List[Optional[UpdateMetadataFieldGroup]]] = Field(default=None, description="List of metadata field groups to be updated", alias="updateMetadataFieldGroups")
    __properties: ClassVar[List[str]] = ["updateSingleMetadataFields", "updateMetadataFieldGroups"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of UpdateMetadata from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in update_single_metadata_fields (list)
        _items = []
        if self.update_single_metadata_fields:
            for _item_update_single_metadata_fields in self.update_single_metadata_fields:
                if _item_update_single_metadata_fields:
                    _items.append(_item_update_single_metadata_fields.to_dict())
            _dict['updateSingleMetadataFields'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in update_metadata_field_groups (list)
        _items = []
        if self.update_metadata_field_groups:
            for _item_update_metadata_field_groups in self.update_metadata_field_groups:
                if _item_update_metadata_field_groups:
                    _items.append(_item_update_metadata_field_groups.to_dict())
            _dict['updateMetadataFieldGroups'] = _items
        # set to None if update_single_metadata_fields (nullable) is None
        # and model_fields_set contains the field
        if self.update_single_metadata_fields is None and "update_single_metadata_fields" in self.model_fields_set:
            _dict['updateSingleMetadataFields'] = None

        # set to None if update_metadata_field_groups (nullable) is None
        # and model_fields_set contains the field
        if self.update_metadata_field_groups is None and "update_metadata_field_groups" in self.model_fields_set:
            _dict['updateMetadataFieldGroups'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of UpdateMetadata from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "updateSingleMetadataFields": [UpdateSingleMetadataField.from_dict(_item) for _item in obj["updateSingleMetadataFields"]] if obj.get("updateSingleMetadataFields") is not None else None,
            "updateMetadataFieldGroups": [UpdateMetadataFieldGroup.from_dict(_item) for _item in obj["updateMetadataFieldGroups"]] if obj.get("updateMetadataFieldGroups") is not None else None
        })
        return _obj

UpdateMetadata

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var update_metadata_field_groups : List[UpdateMetadataFieldGroup | None] | None

The type of the None singleton.

var update_single_metadata_fields : List[UpdateSingleMetadataField] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of UpdateMetadata from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of UpdateMetadata from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in update_single_metadata_fields (list)
    _items = []
    if self.update_single_metadata_fields:
        for _item_update_single_metadata_fields in self.update_single_metadata_fields:
            if _item_update_single_metadata_fields:
                _items.append(_item_update_single_metadata_fields.to_dict())
        _dict['updateSingleMetadataFields'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in update_metadata_field_groups (list)
    _items = []
    if self.update_metadata_field_groups:
        for _item_update_metadata_field_groups in self.update_metadata_field_groups:
            if _item_update_metadata_field_groups:
                _items.append(_item_update_metadata_field_groups.to_dict())
        _dict['updateMetadataFieldGroups'] = _items
    # set to None if update_single_metadata_fields (nullable) is None
    # and model_fields_set contains the field
    if self.update_single_metadata_fields is None and "update_single_metadata_fields" in self.model_fields_set:
        _dict['updateSingleMetadataFields'] = None

    # set to None if update_metadata_field_groups (nullable) is None
    # and model_fields_set contains the field
    if self.update_metadata_field_groups is None and "update_metadata_field_groups" in self.model_fields_set:
        _dict['updateMetadataFieldGroups'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class UpdateMetadataFieldGroup (**data: Any)

Expand source code

class UpdateMetadataFieldGroup(BaseModel):
    """
    List of metadata field groups to be updated
    """ # noqa: E501
    field_id: Optional[FieldId] = Field(default=None, alias="fieldId")
    field_name: Optional[StrictStr] = Field(default=None, description="The field name to be updated. Either the field ID or field name is required.", alias="fieldName")
    index: StrictInt = Field(description="Which metadata row index to update")
    update_single_metadata_fields: List[UpdateSingleMetadataField] = Field(description="List of metadata fields to be updated", alias="updateSingleMetadataFields")
    __properties: ClassVar[List[str]] = ["fieldId", "fieldName", "index", "updateSingleMetadataFields"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of UpdateMetadataFieldGroup from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of field_id
        if self.field_id:
            _dict['fieldId'] = self.field_id.to_dict()
        # override the default output from pydantic by calling `to_dict()` of each item in update_single_metadata_fields (list)
        _items = []
        if self.update_single_metadata_fields:
            for _item_update_single_metadata_fields in self.update_single_metadata_fields:
                if _item_update_single_metadata_fields:
                    _items.append(_item_update_single_metadata_fields.to_dict())
            _dict['updateSingleMetadataFields'] = _items
        # set to None if field_id (nullable) is None
        # and model_fields_set contains the field
        if self.field_id is None and "field_id" in self.model_fields_set:
            _dict['fieldId'] = None

        # set to None if field_name (nullable) is None
        # and model_fields_set contains the field
        if self.field_name is None and "field_name" in self.model_fields_set:
            _dict['fieldName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of UpdateMetadataFieldGroup from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "fieldId": FieldId.from_dict(obj["fieldId"]) if obj.get("fieldId") is not None else None,
            "fieldName": obj.get("fieldName"),
            "index": obj.get("index"),
            "updateSingleMetadataFields": [UpdateSingleMetadataField.from_dict(_item) for _item in obj["updateSingleMetadataFields"]] if obj.get("updateSingleMetadataFields") is not None else None
        })
        return _obj

List of metadata field groups to be updated

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var field_id : FieldId | None

The type of the None singleton.

var field_name : str | None

The type of the None singleton.

var index : int

The type of the None singleton.

var model_config

The type of the None singleton.

var update_single_metadata_fields : List[UpdateSingleMetadataField]

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of UpdateMetadataFieldGroup from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of UpdateMetadataFieldGroup from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of field_id
    if self.field_id:
        _dict['fieldId'] = self.field_id.to_dict()
    # override the default output from pydantic by calling `to_dict()` of each item in update_single_metadata_fields (list)
    _items = []
    if self.update_single_metadata_fields:
        for _item_update_single_metadata_fields in self.update_single_metadata_fields:
            if _item_update_single_metadata_fields:
                _items.append(_item_update_single_metadata_fields.to_dict())
        _dict['updateSingleMetadataFields'] = _items
    # set to None if field_id (nullable) is None
    # and model_fields_set contains the field
    if self.field_id is None and "field_id" in self.model_fields_set:
        _dict['fieldId'] = None

    # set to None if field_name (nullable) is None
    # and model_fields_set contains the field
    if self.field_name is None and "field_name" in self.model_fields_set:
        _dict['fieldName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class UpdateSingleMetadataField (**data: Any)

Expand source code

class UpdateSingleMetadataField(BaseModel):
    """
    List of metadata fields to be updated
    """ # noqa: E501
    field_id: Optional[FieldId] = Field(default=None, alias="fieldId")
    field_name: Optional[StrictStr] = Field(default=None, description="The field name to be updated. Either the field ID or field name is required.", alias="fieldName")
    values: Optional[List[StrictStr]] = Field(default=None, description="The updated value(s)")
    __properties: ClassVar[List[str]] = ["fieldId", "fieldName", "values"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of UpdateSingleMetadataField from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of field_id
        if self.field_id:
            _dict['fieldId'] = self.field_id.to_dict()
        # set to None if field_id (nullable) is None
        # and model_fields_set contains the field
        if self.field_id is None and "field_id" in self.model_fields_set:
            _dict['fieldId'] = None

        # set to None if field_name (nullable) is None
        # and model_fields_set contains the field
        if self.field_name is None and "field_name" in self.model_fields_set:
            _dict['fieldName'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of UpdateSingleMetadataField from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "fieldId": FieldId.from_dict(obj["fieldId"]) if obj.get("fieldId") is not None else None,
            "fieldName": obj.get("fieldName"),
            "values": obj.get("values")
        })
        return _obj

List of metadata fields to be updated

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var field_id : FieldId | None

The type of the None singleton.

var field_name : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var values : List[str] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of UpdateSingleMetadataField from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of UpdateSingleMetadataField from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of field_id
    if self.field_id:
        _dict['fieldId'] = self.field_id.to_dict()
    # set to None if field_id (nullable) is None
    # and model_fields_set contains the field
    if self.field_id is None and "field_id" in self.model_fields_set:
        _dict['fieldId'] = None

    # set to None if field_name (nullable) is None
    # and model_fields_set contains the field
    if self.field_name is None and "field_name" in self.model_fields_set:
        _dict['fieldName'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class UpdateStorageCredentialSecrets (**data: Any)

Expand source code

class UpdateStorageCredentialSecrets(BaseModel):
    """
    UpdateStorageCredentialSecrets
    """ # noqa: E501
    aws_credentials: Optional[AwsCredentials] = Field(default=None, alias="awsCredentials")
    __properties: ClassVar[List[str]] = ["awsCredentials"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of UpdateStorageCredentialSecrets from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of aws_credentials
        if self.aws_credentials:
            _dict['awsCredentials'] = self.aws_credentials.to_dict()
        # set to None if aws_credentials (nullable) is None
        # and model_fields_set contains the field
        if self.aws_credentials is None and "aws_credentials" in self.model_fields_set:
            _dict['awsCredentials'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of UpdateStorageCredentialSecrets from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "awsCredentials": AwsCredentials.from_dict(obj["awsCredentials"]) if obj.get("awsCredentials") is not None else None
        })
        return _obj

UpdateStorageCredentialSecrets

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var aws_credentials : AwsCredentials | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of UpdateStorageCredentialSecrets from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of UpdateStorageCredentialSecrets from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of aws_credentials
    if self.aws_credentials:
        _dict['awsCredentials'] = self.aws_credentials.to_dict()
    # set to None if aws_credentials (nullable) is None
    # and model_fields_set contains the field
    if self.aws_credentials is None and "aws_credentials" in self.model_fields_set:
        _dict['awsCredentials'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Upload (**data: Any)

Expand source code

class Upload(BaseModel):
    """
    Upload
    """ # noqa: E501
    url: StrictStr = Field(description="A pre-signed url which is temporarily available for uploading the data.")
    __properties: ClassVar[List[str]] = ["url"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Upload from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Upload from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "url": obj.get("url")
        })
        return _obj

Upload

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Upload from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Upload from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class UploadRule (**data: Any)

Expand source code

class UploadRule(BaseModel):
    """
    UploadRule
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    code: Annotated[str, Field(min_length=1, strict=True, max_length=300)]
    active: Optional[StrictBool] = None
    description: Optional[Annotated[str, Field(min_length=1, strict=True, max_length=255)]] = None
    local_folder: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The local folder to monitor. Files in this folder on your local environment will be uploaded to the specified project. Only files matching the filePattern will be uploaded.", alias="localFolder")
    file_pattern: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The regular expression to match a file name. eg: to match all files use '.*'", alias="filePattern")
    data_format: Optional[DataFormat] = Field(default=None, alias="dataFormat")
    project: Project
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "code", "active", "description", "localFolder", "filePattern", "dataFormat", "project"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of UploadRule from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of data_format
        if self.data_format:
            _dict['dataFormat'] = self.data_format.to_dict()
        # override the default output from pydantic by calling `to_dict()` of project
        if self.project:
            _dict['project'] = self.project.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if active (nullable) is None
        # and model_fields_set contains the field
        if self.active is None and "active" in self.model_fields_set:
            _dict['active'] = None

        # set to None if description (nullable) is None
        # and model_fields_set contains the field
        if self.description is None and "description" in self.model_fields_set:
            _dict['description'] = None

        # set to None if data_format (nullable) is None
        # and model_fields_set contains the field
        if self.data_format is None and "data_format" in self.model_fields_set:
            _dict['dataFormat'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of UploadRule from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "code": obj.get("code"),
            "active": obj.get("active"),
            "description": obj.get("description"),
            "localFolder": obj.get("localFolder"),
            "filePattern": obj.get("filePattern"),
            "dataFormat": DataFormat.from_dict(obj["dataFormat"]) if obj.get("dataFormat") is not None else None,
            "project": Project.from_dict(obj["project"]) if obj.get("project") is not None else None
        })
        return _obj

UploadRule

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var active : bool | None

The type of the None singleton.

var code : str

The type of the None singleton.

var data_format : DataFormat | None

The type of the None singleton.

var description : str | None

The type of the None singleton.

var file_pattern : str

The type of the None singleton.

var id : str

The type of the None singleton.

var local_folder : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var project : Project

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of UploadRule from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of UploadRule from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of data_format
    if self.data_format:
        _dict['dataFormat'] = self.data_format.to_dict()
    # override the default output from pydantic by calling `to_dict()` of project
    if self.project:
        _dict['project'] = self.project.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if active (nullable) is None
    # and model_fields_set contains the field
    if self.active is None and "active" in self.model_fields_set:
        _dict['active'] = None

    # set to None if description (nullable) is None
    # and model_fields_set contains the field
    if self.description is None and "description" in self.model_fields_set:
        _dict['description'] = None

    # set to None if data_format (nullable) is None
    # and model_fields_set contains the field
    if self.data_format is None and "data_format" in self.model_fields_set:
        _dict['dataFormat'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class UploadRuleList (**data: Any)

Expand source code

class UploadRuleList(BaseModel):
    """
    UploadRuleList
    """ # noqa: E501
    items: List[UploadRule]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of UploadRuleList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of UploadRuleList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [UploadRule.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

UploadRuleList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[UploadRule]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of UploadRuleList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of UploadRuleList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class User (**data: Any)

Expand source code

class User(BaseModel):
    """
    User
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    time_modified: datetime = Field(alias="timeModified")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    username: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    email: Annotated[str, Field(min_length=1, strict=True, max_length=255)]
    firstname: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = None
    lastname: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = None
    active: StrictBool
    tenant_administrator: StrictBool = Field(alias="tenantAdministrator")
    job_title: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = Field(default=None, alias="jobTitle")
    greeting: Optional[StrictStr] = None
    mobile_phone_number: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = Field(default=None, alias="mobilePhoneNumber")
    phone_number: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = Field(default=None, alias="phoneNumber")
    fax_number: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = Field(default=None, alias="faxNumber")
    email_verified: StrictBool = Field(alias="emailVerified")
    two_factor_authentication: StrictBool = Field(alias="twoFactorAuthentication")
    country: Optional[Country] = None
    address_line1: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = Field(default=None, alias="addressLine1")
    address_line2: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = Field(default=None, alias="addressLine2")
    address_line3: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = Field(default=None, alias="addressLine3")
    postal_code: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = Field(default=None, alias="postalCode")
    city: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = None
    state: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=255)]] = None
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "timeModified", "ownerId", "tenantId", "tenantName", "username", "email", "firstname", "lastname", "active", "tenantAdministrator", "jobTitle", "greeting", "mobilePhoneNumber", "phoneNumber", "faxNumber", "emailVerified", "twoFactorAuthentication", "country", "addressLine1", "addressLine2", "addressLine3", "postalCode", "city", "state"]

    @field_validator('greeting')
    def greeting_validate_enum(cls, value):
        """Validates the enum"""
        if value is None:
            return value

        if value not in set(['MR', 'MRS', 'MS', 'MISS', 'DR', 'HR', 'SR']):
            raise ValueError("must be one of enum values ('MR', 'MRS', 'MS', 'MISS', 'DR', 'HR', 'SR')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of User from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of country
        if self.country:
            _dict['country'] = self.country.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if firstname (nullable) is None
        # and model_fields_set contains the field
        if self.firstname is None and "firstname" in self.model_fields_set:
            _dict['firstname'] = None

        # set to None if lastname (nullable) is None
        # and model_fields_set contains the field
        if self.lastname is None and "lastname" in self.model_fields_set:
            _dict['lastname'] = None

        # set to None if job_title (nullable) is None
        # and model_fields_set contains the field
        if self.job_title is None and "job_title" in self.model_fields_set:
            _dict['jobTitle'] = None

        # set to None if greeting (nullable) is None
        # and model_fields_set contains the field
        if self.greeting is None and "greeting" in self.model_fields_set:
            _dict['greeting'] = None

        # set to None if mobile_phone_number (nullable) is None
        # and model_fields_set contains the field
        if self.mobile_phone_number is None and "mobile_phone_number" in self.model_fields_set:
            _dict['mobilePhoneNumber'] = None

        # set to None if phone_number (nullable) is None
        # and model_fields_set contains the field
        if self.phone_number is None and "phone_number" in self.model_fields_set:
            _dict['phoneNumber'] = None

        # set to None if fax_number (nullable) is None
        # and model_fields_set contains the field
        if self.fax_number is None and "fax_number" in self.model_fields_set:
            _dict['faxNumber'] = None

        # set to None if address_line1 (nullable) is None
        # and model_fields_set contains the field
        if self.address_line1 is None and "address_line1" in self.model_fields_set:
            _dict['addressLine1'] = None

        # set to None if address_line2 (nullable) is None
        # and model_fields_set contains the field
        if self.address_line2 is None and "address_line2" in self.model_fields_set:
            _dict['addressLine2'] = None

        # set to None if address_line3 (nullable) is None
        # and model_fields_set contains the field
        if self.address_line3 is None and "address_line3" in self.model_fields_set:
            _dict['addressLine3'] = None

        # set to None if postal_code (nullable) is None
        # and model_fields_set contains the field
        if self.postal_code is None and "postal_code" in self.model_fields_set:
            _dict['postalCode'] = None

        # set to None if city (nullable) is None
        # and model_fields_set contains the field
        if self.city is None and "city" in self.model_fields_set:
            _dict['city'] = None

        # set to None if state (nullable) is None
        # and model_fields_set contains the field
        if self.state is None and "state" in self.model_fields_set:
            _dict['state'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of User from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "timeModified": obj.get("timeModified"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "username": obj.get("username"),
            "email": obj.get("email"),
            "firstname": obj.get("firstname"),
            "lastname": obj.get("lastname"),
            "active": obj.get("active"),
            "tenantAdministrator": obj.get("tenantAdministrator"),
            "jobTitle": obj.get("jobTitle"),
            "greeting": obj.get("greeting"),
            "mobilePhoneNumber": obj.get("mobilePhoneNumber"),
            "phoneNumber": obj.get("phoneNumber"),
            "faxNumber": obj.get("faxNumber"),
            "emailVerified": obj.get("emailVerified"),
            "twoFactorAuthentication": obj.get("twoFactorAuthentication"),
            "country": Country.from_dict(obj["country"]) if obj.get("country") is not None else None,
            "addressLine1": obj.get("addressLine1"),
            "addressLine2": obj.get("addressLine2"),
            "addressLine3": obj.get("addressLine3"),
            "postalCode": obj.get("postalCode"),
            "city": obj.get("city"),
            "state": obj.get("state")
        })
        return _obj

User

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var active : bool

The type of the None singleton.

var address_line1 : str | None

The type of the None singleton.

var address_line2 : str | None

The type of the None singleton.

var address_line3 : str | None

The type of the None singleton.

var city : str | None

The type of the None singleton.

var country : Country | None

The type of the None singleton.

var email : str

The type of the None singleton.

var email_verified : bool

The type of the None singleton.

var fax_number : str | None

The type of the None singleton.

var firstname : str | None

The type of the None singleton.

var greeting : str | None

The type of the None singleton.

var id : str

The type of the None singleton.

var job_title : str | None

The type of the None singleton.

var lastname : str | None

The type of the None singleton.

var mobile_phone_number : str | None

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var phone_number : str | None

The type of the None singleton.

var postal_code : str | None

The type of the None singleton.

var state : str | None

The type of the None singleton.

var tenant_administrator : bool

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var time_modified : datetime.datetime

The type of the None singleton.

var two_factor_authentication : bool

The type of the None singleton.

var username : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of User from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of User from a JSON string

def greeting_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of country
    if self.country:
        _dict['country'] = self.country.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if firstname (nullable) is None
    # and model_fields_set contains the field
    if self.firstname is None and "firstname" in self.model_fields_set:
        _dict['firstname'] = None

    # set to None if lastname (nullable) is None
    # and model_fields_set contains the field
    if self.lastname is None and "lastname" in self.model_fields_set:
        _dict['lastname'] = None

    # set to None if job_title (nullable) is None
    # and model_fields_set contains the field
    if self.job_title is None and "job_title" in self.model_fields_set:
        _dict['jobTitle'] = None

    # set to None if greeting (nullable) is None
    # and model_fields_set contains the field
    if self.greeting is None and "greeting" in self.model_fields_set:
        _dict['greeting'] = None

    # set to None if mobile_phone_number (nullable) is None
    # and model_fields_set contains the field
    if self.mobile_phone_number is None and "mobile_phone_number" in self.model_fields_set:
        _dict['mobilePhoneNumber'] = None

    # set to None if phone_number (nullable) is None
    # and model_fields_set contains the field
    if self.phone_number is None and "phone_number" in self.model_fields_set:
        _dict['phoneNumber'] = None

    # set to None if fax_number (nullable) is None
    # and model_fields_set contains the field
    if self.fax_number is None and "fax_number" in self.model_fields_set:
        _dict['faxNumber'] = None

    # set to None if address_line1 (nullable) is None
    # and model_fields_set contains the field
    if self.address_line1 is None and "address_line1" in self.model_fields_set:
        _dict['addressLine1'] = None

    # set to None if address_line2 (nullable) is None
    # and model_fields_set contains the field
    if self.address_line2 is None and "address_line2" in self.model_fields_set:
        _dict['addressLine2'] = None

    # set to None if address_line3 (nullable) is None
    # and model_fields_set contains the field
    if self.address_line3 is None and "address_line3" in self.model_fields_set:
        _dict['addressLine3'] = None

    # set to None if postal_code (nullable) is None
    # and model_fields_set contains the field
    if self.postal_code is None and "postal_code" in self.model_fields_set:
        _dict['postalCode'] = None

    # set to None if city (nullable) is None
    # and model_fields_set contains the field
    if self.city is None and "city" in self.model_fields_set:
        _dict['city'] = None

    # set to None if state (nullable) is None
    # and model_fields_set contains the field
    if self.state is None and "state" in self.model_fields_set:
        _dict['state'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class UserApi (api_client=None)

Expand source code

class UserApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def approve_user(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Approve a user.

        Endpoint for approving a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._approve_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def approve_user_with_http_info(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Approve a user.

        Endpoint for approving a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._approve_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def approve_user_without_preload_content(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Approve a user.

        Endpoint for approving a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._approve_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _approve_user_serialize(
        self,
        user_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if user_id is not None:
            _path_params['userId'] = user_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/users/{userId}:approve',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def assign_tenant_admin_rights_to_user(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Assign tenant administrator rights to a user.

        Endpoint for assigning tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._assign_tenant_admin_rights_to_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def assign_tenant_admin_rights_to_user_with_http_info(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Assign tenant administrator rights to a user.

        Endpoint for assigning tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._assign_tenant_admin_rights_to_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def assign_tenant_admin_rights_to_user_without_preload_content(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Assign tenant administrator rights to a user.

        Endpoint for assigning tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._assign_tenant_admin_rights_to_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _assign_tenant_admin_rights_to_user_serialize(
        self,
        user_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if user_id is not None:
            _path_params['userId'] = user_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/users/{userId}:assignTenantAdministratorRights',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_user(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> User:
        """Retrieve a user.


        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "User",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_user_with_http_info(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[User]:
        """Retrieve a user.


        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "User",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_user_without_preload_content(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a user.


        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "User",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_user_serialize(
        self,
        user_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if user_id is not None:
            _path_params['userId'] = user_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/users/{userId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_users(
        self,
        email_address: Annotated[Optional[StrictStr], Field(description="The email address to filter on")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> UserList:
        """Retrieve a list of users.


        :param email_address: The email address to filter on
        :type email_address: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_users_serialize(
            email_address=email_address,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UserList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_users_with_http_info(
        self,
        email_address: Annotated[Optional[StrictStr], Field(description="The email address to filter on")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[UserList]:
        """Retrieve a list of users.


        :param email_address: The email address to filter on
        :type email_address: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_users_serialize(
            email_address=email_address,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UserList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_users_without_preload_content(
        self,
        email_address: Annotated[Optional[StrictStr], Field(description="The email address to filter on")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of users.


        :param email_address: The email address to filter on
        :type email_address: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_users_serialize(
            email_address=email_address,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "UserList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_users_serialize(
        self,
        email_address,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        if email_address is not None:
            
            _query_params.append(('emailAddress', email_address))
            
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/users',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def revoke_tenant_admin_rights_to_user(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> None:
        """Revoke tenant administrator rights to a user.

        Endpoint for revoking tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._revoke_tenant_admin_rights_to_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def revoke_tenant_admin_rights_to_user_with_http_info(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[None]:
        """Revoke tenant administrator rights to a user.

        Endpoint for revoking tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._revoke_tenant_admin_rights_to_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def revoke_tenant_admin_rights_to_user_without_preload_content(
        self,
        user_id: StrictStr,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Revoke tenant administrator rights to a user.

        Endpoint for revoking tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

        :param user_id: (required)
        :type user_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._revoke_tenant_admin_rights_to_user_serialize(
            user_id=user_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '204': None,
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _revoke_tenant_admin_rights_to_user_serialize(
        self,
        user_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if user_id is not None:
            _path_params['userId'] = user_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='POST',
            resource_path='/api/users/{userId}:revokeTenantAdministratorRights',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def update_user(
        self,
        user_id: StrictStr,
        user: User,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> User:
        """Update a user.

        Fields which can be updated: - greeting - two factor authentication - job title - first name - last name - mobile phone number - phone number - fax number - address lines - postal code - city - country - state

        :param user_id: (required)
        :type user_id: str
        :param user: (required)
        :type user: User
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_user_serialize(
            user_id=user_id,
            user=user,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "User",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def update_user_with_http_info(
        self,
        user_id: StrictStr,
        user: User,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[User]:
        """Update a user.

        Fields which can be updated: - greeting - two factor authentication - job title - first name - last name - mobile phone number - phone number - fax number - address lines - postal code - city - country - state

        :param user_id: (required)
        :type user_id: str
        :param user: (required)
        :type user: User
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_user_serialize(
            user_id=user_id,
            user=user,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "User",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def update_user_without_preload_content(
        self,
        user_id: StrictStr,
        user: User,
        if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Update a user.

        Fields which can be updated: - greeting - two factor authentication - job title - first name - last name - mobile phone number - phone number - fax number - address lines - postal code - city - country - state

        :param user_id: (required)
        :type user_id: str
        :param user: (required)
        :type user: User
        :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
        :type if_match: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._update_user_serialize(
            user_id=user_id,
            user=user,
            if_match=if_match,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "User",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _update_user_serialize(
        self,
        user_id,
        user,
        if_match,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if user_id is not None:
            _path_params['userId'] = user_id
        # process the query parameters
        # process the header parameters
        if if_match is not None:
            _header_params['If-Match'] = if_match
        # process the form parameters
        # process the body parameter
        if user is not None:
            _body_params = user


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )

        # set the HTTP header `Content-Type`
        if _content_type:
            _header_params['Content-Type'] = _content_type
        else:
            _default_content_type = (
                self.api_client.select_header_content_type(
                    [
                        'application/vnd.illumina.v3+json', 
                        'application/json'
                    ]
                )
            )
            if _default_content_type is not None:
                _header_params['Content-Type'] = _default_content_type

        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='PUT',
            resource_path='/api/users/{userId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def approve_user(self, user_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def approve_user(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Approve a user.

    Endpoint for approving a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._approve_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Approve a user.

Endpoint for approving a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def approve_user_with_http_info(self, user_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def approve_user_with_http_info(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Approve a user.

    Endpoint for approving a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._approve_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Approve a user.

Endpoint for approving a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def approve_user_without_preload_content(self, user_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def approve_user_without_preload_content(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Approve a user.

    Endpoint for approving a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._approve_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Approve a user.

Endpoint for approving a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def assign_tenant_admin_rights_to_user(self, user_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def assign_tenant_admin_rights_to_user(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Assign tenant administrator rights to a user.

    Endpoint for assigning tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._assign_tenant_admin_rights_to_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Assign tenant administrator rights to a user.

Endpoint for assigning tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def assign_tenant_admin_rights_to_user_with_http_info(self, user_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def assign_tenant_admin_rights_to_user_with_http_info(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Assign tenant administrator rights to a user.

    Endpoint for assigning tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._assign_tenant_admin_rights_to_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Assign tenant administrator rights to a user.

Endpoint for assigning tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def assign_tenant_admin_rights_to_user_without_preload_content(self, user_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def assign_tenant_admin_rights_to_user_without_preload_content(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Assign tenant administrator rights to a user.

    Endpoint for assigning tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._assign_tenant_admin_rights_to_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Assign tenant administrator rights to a user.

Endpoint for assigning tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_user(self, user_id: Annotated[str, Strict(strict=True)]) ‑> User

Expand source code

@validate_call
def get_user(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> User:
    """Retrieve a user.


    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "User",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a user.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_user_with_http_info(self, user_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[User]

Expand source code

@validate_call
def get_user_with_http_info(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[User]:
    """Retrieve a user.


    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "User",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a user.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_user_without_preload_content(self, user_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_user_without_preload_content(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a user.


    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "User",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a user.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_users(self,
email_address: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The email address to filter on')] = None) ‑> UserList

Expand source code

@validate_call
def get_users(
    self,
    email_address: Annotated[Optional[StrictStr], Field(description="The email address to filter on")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> UserList:
    """Retrieve a list of users.


    :param email_address: The email address to filter on
    :type email_address: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_users_serialize(
        email_address=email_address,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UserList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of users.

:param email_address: The email address to filter on :type email_address: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_users_with_http_info(self,
email_address: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The email address to filter on')] = None) ‑> ApiResponse[UserList]

Expand source code

@validate_call
def get_users_with_http_info(
    self,
    email_address: Annotated[Optional[StrictStr], Field(description="The email address to filter on")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[UserList]:
    """Retrieve a list of users.


    :param email_address: The email address to filter on
    :type email_address: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_users_serialize(
        email_address=email_address,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UserList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of users.

:param email_address: The email address to filter on :type email_address: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_users_without_preload_content(self,
email_address: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='The email address to filter on')] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_users_without_preload_content(
    self,
    email_address: Annotated[Optional[StrictStr], Field(description="The email address to filter on")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of users.


    :param email_address: The email address to filter on
    :type email_address: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_users_serialize(
        email_address=email_address,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "UserList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of users.

:param email_address: The email address to filter on :type email_address: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def revoke_tenant_admin_rights_to_user(self, user_id: Annotated[str, Strict(strict=True)]) ‑> None

Expand source code

@validate_call
def revoke_tenant_admin_rights_to_user(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> None:
    """Revoke tenant administrator rights to a user.

    Endpoint for revoking tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._revoke_tenant_admin_rights_to_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Revoke tenant administrator rights to a user.

Endpoint for revoking tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def revoke_tenant_admin_rights_to_user_with_http_info(self, user_id: Annotated[str, Strict(strict=True)]) ‑> ApiResponse[NoneType]

Expand source code

@validate_call
def revoke_tenant_admin_rights_to_user_with_http_info(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[None]:
    """Revoke tenant administrator rights to a user.

    Endpoint for revoking tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._revoke_tenant_admin_rights_to_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Revoke tenant administrator rights to a user.

Endpoint for revoking tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def revoke_tenant_admin_rights_to_user_without_preload_content(self, user_id: Annotated[str, Strict(strict=True)]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def revoke_tenant_admin_rights_to_user_without_preload_content(
    self,
    user_id: StrictStr,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Revoke tenant administrator rights to a user.

    Endpoint for revoking tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

    :param user_id: (required)
    :type user_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._revoke_tenant_admin_rights_to_user_serialize(
        user_id=user_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '204': None,
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Revoke tenant administrator rights to a user.

Endpoint for revoking tenant administrator rights to a user.This is a non-RESTful endpoint, as the path of this endpoint is not representing a REST resource.

:param user_id: (required) :type user_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_user(self,
user_id: Annotated[str, Strict(strict=True)],
user: User,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> User

Expand source code

@validate_call
def update_user(
    self,
    user_id: StrictStr,
    user: User,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> User:
    """Update a user.

    Fields which can be updated: - greeting - two factor authentication - job title - first name - last name - mobile phone number - phone number - fax number - address lines - postal code - city - country - state

    :param user_id: (required)
    :type user_id: str
    :param user: (required)
    :type user: User
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_user_serialize(
        user_id=user_id,
        user=user,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "User",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Update a user.

Fields which can be updated: - greeting - two factor authentication - job title - first name - last name - mobile phone number - phone number - fax number - address lines - postal code - city - country - state

:param user_id: (required) :type user_id: str :param user: (required) :type user: User :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_user_with_http_info(self,
user_id: Annotated[str, Strict(strict=True)],
user: User,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> ApiResponse[User]

Expand source code

@validate_call
def update_user_with_http_info(
    self,
    user_id: StrictStr,
    user: User,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[User]:
    """Update a user.

    Fields which can be updated: - greeting - two factor authentication - job title - first name - last name - mobile phone number - phone number - fax number - address lines - postal code - city - country - state

    :param user_id: (required)
    :type user_id: str
    :param user: (required)
    :type user: User
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_user_serialize(
        user_id=user_id,
        user=user,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "User",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Update a user.

Fields which can be updated: - greeting - two factor authentication - job title - first name - last name - mobile phone number - phone number - fax number - address lines - postal code - city - country - state

:param user_id: (required) :type user_id: str :param user: (required) :type user: User :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def update_user_without_preload_content(self,
user_id: Annotated[str, Strict(strict=True)],
user: User,
if_match: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def update_user_without_preload_content(
    self,
    user_id: StrictStr,
    user: User,
    if_match: Annotated[Optional[StrictStr], Field(description="Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.")] = None,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Update a user.

    Fields which can be updated: - greeting - two factor authentication - job title - first name - last name - mobile phone number - phone number - fax number - address lines - postal code - city - country - state

    :param user_id: (required)
    :type user_id: str
    :param user: (required)
    :type user: User
    :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version.
    :type if_match: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._update_user_serialize(
        user_id=user_id,
        user=user,
        if_match=if_match,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "User",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Update a user.

Fields which can be updated: - greeting - two factor authentication - job title - first name - last name - mobile phone number - phone number - fax number - address lines - postal code - city - country - state

:param user_id: (required) :type user_id: str :param user: (required) :type user: User :param if_match: Optional header parameter to enable conflict exposure. If the client provides this header, then it must contains the client's most recent value of the 'ETag' response header, and the server will respond with a 409 code if it detects a conflict. If the client does not provide this header, then the server will not do a conflict check, which means that as a client you can override the resource even when the server has a more recent version. :type if_match: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class UserIdentifier (**data: Any)

Expand source code

class UserIdentifier(BaseModel):
    """
    UserIdentifier
    """ # noqa: E501
    id: StrictStr
    __properties: ClassVar[List[str]] = ["id"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of UserIdentifier from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of UserIdentifier from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id")
        })
        return _obj

UserIdentifier

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of UserIdentifier from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of UserIdentifier from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class UserList (**data: Any)

Expand source code

class UserList(BaseModel):
    """
    UserList
    """ # noqa: E501
    items: List[User]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of UserList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of UserList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [User.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

UserList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[User]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of UserList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of UserList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionAnalysisPagedListV4 (**data: Any)

Expand source code

class WorkflowSessionAnalysisPagedListV4(BaseModel):
    """
    WorkflowSessionAnalysisPagedListV4
    """ # noqa: E501
    items: List[WorkflowSessionAnalysisV4]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionAnalysisPagedListV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionAnalysisPagedListV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [WorkflowSessionAnalysisV4.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

WorkflowSessionAnalysisPagedListV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[WorkflowSessionAnalysisV4]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionAnalysisPagedListV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionAnalysisPagedListV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionAnalysisV4 (**data: Any)

Expand source code

class WorkflowSessionAnalysisV4(BaseModel):
    """
    WorkflowSessionAnalysisV4
    """ # noqa: E501
    analysis: AnalysisV4
    project: Project
    workflow_session_id: StrictStr = Field(alias="workflowSessionId")
    __properties: ClassVar[List[str]] = ["analysis", "project", "workflowSessionId"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionAnalysisV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of analysis
        if self.analysis:
            _dict['analysis'] = self.analysis.to_dict()
        # override the default output from pydantic by calling `to_dict()` of project
        if self.project:
            _dict['project'] = self.project.to_dict()
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionAnalysisV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "analysis": AnalysisV4.from_dict(obj["analysis"]) if obj.get("analysis") is not None else None,
            "project": Project.from_dict(obj["project"]) if obj.get("project") is not None else None,
            "workflowSessionId": obj.get("workflowSessionId")
        })
        return _obj

WorkflowSessionAnalysisV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis : AnalysisV4

The type of the None singleton.

var model_config

The type of the None singleton.

var project : Project

The type of the None singleton.

var workflow_session_id : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionAnalysisV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionAnalysisV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of analysis
    if self.analysis:
        _dict['analysis'] = self.analysis.to_dict()
    # override the default output from pydantic by calling `to_dict()` of project
    if self.project:
        _dict['project'] = self.project.to_dict()
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionConfiguration (**data: Any)

Expand source code

class WorkflowSessionConfiguration(BaseModel):
    """
    WorkflowSessionConfiguration
    """ # noqa: E501
    name: StrictStr = Field(description="The name of the configuration")
    multi_value: StrictBool = Field(description="Whether the configuration has multiple values", alias="multiValue")
    values: List[StrictStr] = Field(description="The configuration values")
    __properties: ClassVar[List[str]] = ["name", "multiValue", "values"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionConfiguration from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionConfiguration from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "name": obj.get("name"),
            "multiValue": obj.get("multiValue"),
            "values": obj.get("values")
        })
        return _obj

WorkflowSessionConfiguration

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var multi_value : bool

The type of the None singleton.

var name : str

The type of the None singleton.

var values : List[str]

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionConfiguration from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionConfiguration from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionConfigurationList (**data: Any)

Expand source code

class WorkflowSessionConfigurationList(BaseModel):
    """
    WorkflowSessionConfigurationList
    """ # noqa: E501
    items: List[WorkflowSessionConfiguration]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionConfigurationList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionConfigurationList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [WorkflowSessionConfiguration.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

WorkflowSessionConfigurationList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[WorkflowSessionConfiguration]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionConfigurationList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionConfigurationList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionData (**data: Any)

Expand source code

class WorkflowSessionData(BaseModel):
    """
    The workflow-session-data used as input by the workflow session.
    """ # noqa: E501
    data_id: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The id of the file/folder.", alias="dataId")
    format: Optional[DataFormat]
    name: StrictStr = Field(description="The name of the file/folder as it was processed by the workflow session.")
    data_type: StrictStr = Field(alias="dataType")
    mount_path: Optional[StrictStr] = Field(default=None, description="The requested location where the input file was located on the machine that was running the workflow.", alias="mountPath")
    __properties: ClassVar[List[str]] = ["dataId", "format", "name", "dataType", "mountPath"]

    @field_validator('data_type')
    def data_type_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['FILE', 'FOLDER']):
            raise ValueError("must be one of enum values ('FILE', 'FOLDER')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of format
        if self.format:
            _dict['format'] = self.format.to_dict()
        # set to None if format (nullable) is None
        # and model_fields_set contains the field
        if self.format is None and "format" in self.model_fields_set:
            _dict['format'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "dataId": obj.get("dataId"),
            "format": DataFormat.from_dict(obj["format"]) if obj.get("format") is not None else None,
            "name": obj.get("name"),
            "dataType": obj.get("dataType"),
            "mountPath": obj.get("mountPath")
        })
        return _obj

The workflow-session-data used as input by the workflow session.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var data_id : str

The type of the None singleton.

var data_type : str

The type of the None singleton.

var format : DataFormat | None

The type of the None singleton.

var model_config

The type of the None singleton.

var mount_path : str | None

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def data_type_validate_enum(value)

Validates the enum

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of format
    if self.format:
        _dict['format'] = self.format.to_dict()
    # set to None if format (nullable) is None
    # and model_fields_set contains the field
    if self.format is None and "format" in self.model_fields_set:
        _dict['format'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionExternalData (**data: Any)

Expand source code

class WorkflowSessionExternalData(BaseModel):
    """
    The external data used as input by the workflow session.
    """ # noqa: E501
    url: StrictStr
    type: StrictStr = Field(description="Possible values are: s3, http, basespace. More types could be added in a future release.")
    mount_path: StrictStr = Field(alias="mountPath")
    __properties: ClassVar[List[str]] = ["url", "type", "mountPath"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionExternalData from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionExternalData from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "url": obj.get("url"),
            "type": obj.get("type"),
            "mountPath": obj.get("mountPath")
        })
        return _obj

The external data used as input by the workflow session.

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var mount_path : str

The type of the None singleton.

var type : str

The type of the None singleton.

var url : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionExternalData from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionExternalData from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionInput (**data: Any)

Expand source code

class WorkflowSessionInput(BaseModel):
    """
    WorkflowSessionInput
    """ # noqa: E501
    code: StrictStr = Field(description="The name of the input-parameter.")
    analysis_data: Optional[List[Optional[WorkflowSessionData]]] = Field(default=None, description="The workflow-session-data used as input by the workflow session.", alias="analysisData")
    external_data: Optional[List[Optional[WorkflowSessionExternalData]]] = Field(default=None, description="The external data used as input by the workflow session.", alias="externalData")
    __properties: ClassVar[List[str]] = ["code", "analysisData", "externalData"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionInput from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in analysis_data (list)
        _items = []
        if self.analysis_data:
            for _item_analysis_data in self.analysis_data:
                if _item_analysis_data:
                    _items.append(_item_analysis_data.to_dict())
            _dict['analysisData'] = _items
        # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
        _items = []
        if self.external_data:
            for _item_external_data in self.external_data:
                if _item_external_data:
                    _items.append(_item_external_data.to_dict())
            _dict['externalData'] = _items
        # set to None if analysis_data (nullable) is None
        # and model_fields_set contains the field
        if self.analysis_data is None and "analysis_data" in self.model_fields_set:
            _dict['analysisData'] = None

        # set to None if external_data (nullable) is None
        # and model_fields_set contains the field
        if self.external_data is None and "external_data" in self.model_fields_set:
            _dict['externalData'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionInput from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "code": obj.get("code"),
            "analysisData": [WorkflowSessionData.from_dict(_item) for _item in obj["analysisData"]] if obj.get("analysisData") is not None else None,
            "externalData": [WorkflowSessionExternalData.from_dict(_item) for _item in obj["externalData"]] if obj.get("externalData") is not None else None
        })
        return _obj

WorkflowSessionInput

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_data : List[WorkflowSessionData | None] | None

The type of the None singleton.

var code : str

The type of the None singleton.

var external_data : List[WorkflowSessionExternalData | None] | None

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionInput from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionInput from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in analysis_data (list)
    _items = []
    if self.analysis_data:
        for _item_analysis_data in self.analysis_data:
            if _item_analysis_data:
                _items.append(_item_analysis_data.to_dict())
        _dict['analysisData'] = _items
    # override the default output from pydantic by calling `to_dict()` of each item in external_data (list)
    _items = []
    if self.external_data:
        for _item_external_data in self.external_data:
            if _item_external_data:
                _items.append(_item_external_data.to_dict())
        _dict['externalData'] = _items
    # set to None if analysis_data (nullable) is None
    # and model_fields_set contains the field
    if self.analysis_data is None and "analysis_data" in self.model_fields_set:
        _dict['analysisData'] = None

    # set to None if external_data (nullable) is None
    # and model_fields_set contains the field
    if self.external_data is None and "external_data" in self.model_fields_set:
        _dict['externalData'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionInputList (**data: Any)

Expand source code

class WorkflowSessionInputList(BaseModel):
    """
    WorkflowSessionInputList
    """ # noqa: E501
    items: List[WorkflowSessionInput]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionInputList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionInputList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [WorkflowSessionInput.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

WorkflowSessionInputList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[WorkflowSessionInput]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionInputList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionInputList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionPagedListV3 (**data: Any)

Expand source code

class WorkflowSessionPagedListV3(BaseModel):
    """
    WorkflowSessionPagedListV3
    """ # noqa: E501
    items: List[WorkflowSessionV3]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionPagedListV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionPagedListV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [WorkflowSessionV3.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

WorkflowSessionPagedListV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[WorkflowSessionV3]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionPagedListV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionPagedListV3 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionPagedListV4 (**data: Any)

Expand source code

class WorkflowSessionPagedListV4(BaseModel):
    """
    WorkflowSessionPagedListV4
    """ # noqa: E501
    items: List[WorkflowSessionV4]
    next_page_token: Optional[Annotated[str, Field(min_length=0, strict=True, max_length=2000)]] = Field(default=None, description="The cursor to request the next page. For offset-based paging the value is an empty string.", alias="nextPageToken")
    remaining_records: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The number of records remaining (used in cursor based pagination)", alias="remainingRecords")
    total_item_count: Optional[Annotated[int, Field(strict=True, ge=0)]] = Field(default=None, description="The total number of records matching the search criteria (used in offset based pagination)", alias="totalItemCount")
    __properties: ClassVar[List[str]] = ["items", "nextPageToken", "remainingRecords", "totalItemCount"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionPagedListV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        # set to None if next_page_token (nullable) is None
        # and model_fields_set contains the field
        if self.next_page_token is None and "next_page_token" in self.model_fields_set:
            _dict['nextPageToken'] = None

        # set to None if remaining_records (nullable) is None
        # and model_fields_set contains the field
        if self.remaining_records is None and "remaining_records" in self.model_fields_set:
            _dict['remainingRecords'] = None

        # set to None if total_item_count (nullable) is None
        # and model_fields_set contains the field
        if self.total_item_count is None and "total_item_count" in self.model_fields_set:
            _dict['totalItemCount'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionPagedListV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [WorkflowSessionV4.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None,
            "nextPageToken": obj.get("nextPageToken"),
            "remainingRecords": obj.get("remainingRecords"),
            "totalItemCount": obj.get("totalItemCount")
        })
        return _obj

WorkflowSessionPagedListV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[WorkflowSessionV4]

The type of the None singleton.

var model_config

The type of the None singleton.

var next_page_token : str | None

The type of the None singleton.

var remaining_records : int | None

The type of the None singleton.

var total_item_count : int | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionPagedListV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionPagedListV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    # set to None if next_page_token (nullable) is None
    # and model_fields_set contains the field
    if self.next_page_token is None and "next_page_token" in self.model_fields_set:
        _dict['nextPageToken'] = None

    # set to None if remaining_records (nullable) is None
    # and model_fields_set contains the field
    if self.remaining_records is None and "remaining_records" in self.model_fields_set:
        _dict['remainingRecords'] = None

    # set to None if total_item_count (nullable) is None
    # and model_fields_set contains the field
    if self.total_item_count is None and "total_item_count" in self.model_fields_set:
        _dict['totalItemCount'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionTag (**data: Any)

Expand source code

class WorkflowSessionTag(BaseModel):
    """
    WorkflowSessionTag
    """ # noqa: E501
    technical_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="Technical tags", alias="technicalTags")
    user_tags: Optional[List[Optional[StrictStr]]] = Field(default=None, description="User tags", alias="userTags")
    __properties: ClassVar[List[str]] = ["technicalTags", "userTags"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionTag from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # set to None if technical_tags (nullable) is None
        # and model_fields_set contains the field
        if self.technical_tags is None and "technical_tags" in self.model_fields_set:
            _dict['technicalTags'] = None

        # set to None if user_tags (nullable) is None
        # and model_fields_set contains the field
        if self.user_tags is None and "user_tags" in self.model_fields_set:
            _dict['userTags'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionTag from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "technicalTags": obj.get("technicalTags"),
            "userTags": obj.get("userTags")
        })
        return _obj

WorkflowSessionTag

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var model_config

The type of the None singleton.

var technical_tags : List[str | None] | None

The type of the None singleton.

var user_tags : List[str | None] | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionTag from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionTag from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # set to None if technical_tags (nullable) is None
    # and model_fields_set contains the field
    if self.technical_tags is None and "technical_tags" in self.model_fields_set:
        _dict['technicalTags'] = None

    # set to None if user_tags (nullable) is None
    # and model_fields_set contains the field
    if self.user_tags is None and "user_tags" in self.model_fields_set:
        _dict['userTags'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionV3 (**data: Any)

Expand source code

class WorkflowSessionV3(BaseModel):
    """
    WorkflowSessionV3
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    owner_id: StrictStr = Field(alias="ownerId")
    tenant_id: StrictStr = Field(alias="tenantId")
    tenant_name: Optional[StrictStr] = Field(default=None, alias="tenantName")
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user reference of the workflow session", alias="userReference")
    workflow: WorkflowV3
    status: StrictStr = Field(description="The status of the workflow session")
    start_date: Optional[datetime] = Field(default=None, description="When the workflow session was started", alias="startDate")
    end_date: Optional[datetime] = Field(default=None, description="When the workflow session was finished", alias="endDate")
    summary: Optional[StrictStr] = Field(default=None, description="The summary of the workflow session")
    tags: WorkflowSessionTag
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "ownerId", "tenantId", "tenantName", "userReference", "workflow", "status", "startDate", "endDate", "summary", "tags"]

    @field_validator('status')
    def status_validate_enum(cls, value):
        """Validates the enum"""
        if value not in set(['REQUESTED', 'AWAITINGINPUT', 'INPROGRESS', 'SUCCEEDED', 'FAILED', 'FAILEDFINAL', 'ABORTED']):
            raise ValueError("must be one of enum values ('REQUESTED', 'AWAITINGINPUT', 'INPROGRESS', 'SUCCEEDED', 'FAILED', 'FAILEDFINAL', 'ABORTED')")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of workflow
        if self.workflow:
            _dict['workflow'] = self.workflow.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # set to None if tenant_name (nullable) is None
        # and model_fields_set contains the field
        if self.tenant_name is None and "tenant_name" in self.model_fields_set:
            _dict['tenantName'] = None

        # set to None if start_date (nullable) is None
        # and model_fields_set contains the field
        if self.start_date is None and "start_date" in self.model_fields_set:
            _dict['startDate'] = None

        # set to None if end_date (nullable) is None
        # and model_fields_set contains the field
        if self.end_date is None and "end_date" in self.model_fields_set:
            _dict['endDate'] = None

        # set to None if summary (nullable) is None
        # and model_fields_set contains the field
        if self.summary is None and "summary" in self.model_fields_set:
            _dict['summary'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "ownerId": obj.get("ownerId"),
            "tenantId": obj.get("tenantId"),
            "tenantName": obj.get("tenantName"),
            "userReference": obj.get("userReference"),
            "workflow": WorkflowV3.from_dict(obj["workflow"]) if obj.get("workflow") is not None else None,
            "status": obj.get("status"),
            "startDate": obj.get("startDate"),
            "endDate": obj.get("endDate"),
            "summary": obj.get("summary"),
            "tags": WorkflowSessionTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None
        })
        return _obj

WorkflowSessionV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var end_date : datetime.datetime | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner_id : str

The type of the None singleton.

var start_date : datetime.datetime | None

The type of the None singleton.

var status : str

The type of the None singleton.

var summary : str | None

The type of the None singleton.

var tags : WorkflowSessionTag

The type of the None singleton.

var tenant_id : str

The type of the None singleton.

var tenant_name : str | None

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var user_reference : str

The type of the None singleton.

var workflow : WorkflowV3

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionV3 from a JSON string

def status_validate_enum(value)

Validates the enum

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of workflow
    if self.workflow:
        _dict['workflow'] = self.workflow.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # set to None if tenant_name (nullable) is None
    # and model_fields_set contains the field
    if self.tenant_name is None and "tenant_name" in self.model_fields_set:
        _dict['tenantName'] = None

    # set to None if start_date (nullable) is None
    # and model_fields_set contains the field
    if self.start_date is None and "start_date" in self.model_fields_set:
        _dict['startDate'] = None

    # set to None if end_date (nullable) is None
    # and model_fields_set contains the field
    if self.end_date is None and "end_date" in self.model_fields_set:
        _dict['endDate'] = None

    # set to None if summary (nullable) is None
    # and model_fields_set contains the field
    if self.summary is None and "summary" in self.model_fields_set:
        _dict['summary'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowSessionV4 (**data: Any)

Expand source code

class WorkflowSessionV4(BaseModel):
    """
    WorkflowSessionV4
    """ # noqa: E501
    id: StrictStr
    time_created: datetime = Field(alias="timeCreated")
    owner: UserIdentifier
    tenant: TenantIdentifier
    user_reference: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The user reference of the workflow session", alias="userReference")
    workflow: WorkflowV4
    status: Annotated[str, Field(strict=True)] = Field(description="The status of the workflow session")
    start_date: Optional[datetime] = Field(default=None, description="When the workflow session was started", alias="startDate")
    end_date: Optional[datetime] = Field(default=None, description="When the workflow session was finished", alias="endDate")
    summary: Optional[StrictStr] = Field(default=None, description="The summary of the workflow session")
    tags: WorkflowSessionTag
    __properties: ClassVar[List[str]] = ["id", "timeCreated", "owner", "tenant", "userReference", "workflow", "status", "startDate", "endDate", "summary", "tags"]

    @field_validator('status')
    def status_validate_regular_expression(cls, value):
        """Validates the regular expression"""
        if not re.match(r"REQUESTED|QUEUED|INITIALIZING|PREPARING_INPUTS|IN_PROGRESS|GENERATING_OUTPUTS|AWAITING_INPUT|ABORTING|SUCCEEDED|FAILED|FAILED_FINAL|ABORTED", value):
            raise ValueError(r"must validate the regular expression /REQUESTED|QUEUED|INITIALIZING|PREPARING_INPUTS|IN_PROGRESS|GENERATING_OUTPUTS|AWAITING_INPUT|ABORTING|SUCCEEDED|FAILED|FAILED_FINAL|ABORTED/")
        return value

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowSessionV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of owner
        if self.owner:
            _dict['owner'] = self.owner.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tenant
        if self.tenant:
            _dict['tenant'] = self.tenant.to_dict()
        # override the default output from pydantic by calling `to_dict()` of workflow
        if self.workflow:
            _dict['workflow'] = self.workflow.to_dict()
        # override the default output from pydantic by calling `to_dict()` of tags
        if self.tags:
            _dict['tags'] = self.tags.to_dict()
        # set to None if start_date (nullable) is None
        # and model_fields_set contains the field
        if self.start_date is None and "start_date" in self.model_fields_set:
            _dict['startDate'] = None

        # set to None if end_date (nullable) is None
        # and model_fields_set contains the field
        if self.end_date is None and "end_date" in self.model_fields_set:
            _dict['endDate'] = None

        # set to None if summary (nullable) is None
        # and model_fields_set contains the field
        if self.summary is None and "summary" in self.model_fields_set:
            _dict['summary'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowSessionV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "timeCreated": obj.get("timeCreated"),
            "owner": UserIdentifier.from_dict(obj["owner"]) if obj.get("owner") is not None else None,
            "tenant": TenantIdentifier.from_dict(obj["tenant"]) if obj.get("tenant") is not None else None,
            "userReference": obj.get("userReference"),
            "workflow": WorkflowV4.from_dict(obj["workflow"]) if obj.get("workflow") is not None else None,
            "status": obj.get("status"),
            "startDate": obj.get("startDate"),
            "endDate": obj.get("endDate"),
            "summary": obj.get("summary"),
            "tags": WorkflowSessionTag.from_dict(obj["tags"]) if obj.get("tags") is not None else None
        })
        return _obj

WorkflowSessionV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var end_date : datetime.datetime | None

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var owner : UserIdentifier

The type of the None singleton.

var start_date : datetime.datetime | None

The type of the None singleton.

var status : str

The type of the None singleton.

var summary : str | None

The type of the None singleton.

var tags : WorkflowSessionTag

The type of the None singleton.

var tenant : TenantIdentifier

The type of the None singleton.

var time_created : datetime.datetime

The type of the None singleton.

var user_reference : str

The type of the None singleton.

var workflow : WorkflowV4

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowSessionV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowSessionV4 from a JSON string

def status_validate_regular_expression(value)

Validates the regular expression

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of owner
    if self.owner:
        _dict['owner'] = self.owner.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tenant
    if self.tenant:
        _dict['tenant'] = self.tenant.to_dict()
    # override the default output from pydantic by calling `to_dict()` of workflow
    if self.workflow:
        _dict['workflow'] = self.workflow.to_dict()
    # override the default output from pydantic by calling `to_dict()` of tags
    if self.tags:
        _dict['tags'] = self.tags.to_dict()
    # set to None if start_date (nullable) is None
    # and model_fields_set contains the field
    if self.start_date is None and "start_date" in self.model_fields_set:
        _dict['startDate'] = None

    # set to None if end_date (nullable) is None
    # and model_fields_set contains the field
    if self.end_date is None and "end_date" in self.model_fields_set:
        _dict['endDate'] = None

    # set to None if summary (nullable) is None
    # and model_fields_set contains the field
    if self.summary is None and "summary" in self.model_fields_set:
        _dict['summary'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowV3 (**data: Any)

Expand source code

class WorkflowV3(BaseModel):
    """
    WorkflowV3
    """ # noqa: E501
    id: StrictStr
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The code of the workflow")
    urn: Annotated[str, Field(min_length=1, strict=True, max_length=2000)] = Field(description="The URN of the workflow. The format is urn:ilmn:ica:\\<type of the object\\>:\\<ID of the object\\>#\\<optional human readable hint representing the object\\>. The hint can be omitted, in that case the hashtag (#) must also be omitted.")
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000)] = Field(description="The description of the workflow")
    language_version: Optional[PipelineLanguageVersion] = Field(default=None, alias="languageVersion")
    workflow_tags: Optional[PipelineTag] = Field(default=None, alias="workflowTags")
    analysis_storage: AnalysisStorageV3 = Field(alias="analysisStorage")
    __properties: ClassVar[List[str]] = ["id", "code", "urn", "description", "languageVersion", "workflowTags", "analysisStorage"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowV3 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of language_version
        if self.language_version:
            _dict['languageVersion'] = self.language_version.to_dict()
        # override the default output from pydantic by calling `to_dict()` of workflow_tags
        if self.workflow_tags:
            _dict['workflowTags'] = self.workflow_tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of analysis_storage
        if self.analysis_storage:
            _dict['analysisStorage'] = self.analysis_storage.to_dict()
        # set to None if language_version (nullable) is None
        # and model_fields_set contains the field
        if self.language_version is None and "language_version" in self.model_fields_set:
            _dict['languageVersion'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowV3 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "code": obj.get("code"),
            "urn": obj.get("urn"),
            "description": obj.get("description"),
            "languageVersion": PipelineLanguageVersion.from_dict(obj["languageVersion"]) if obj.get("languageVersion") is not None else None,
            "workflowTags": PipelineTag.from_dict(obj["workflowTags"]) if obj.get("workflowTags") is not None else None,
            "analysisStorage": AnalysisStorageV3.from_dict(obj["analysisStorage"]) if obj.get("analysisStorage") is not None else None
        })
        return _obj

WorkflowV3

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_storage : AnalysisStorageV3

The type of the None singleton.

var code : str

The type of the None singleton.

var description : str

The type of the None singleton.

var id : str

The type of the None singleton.

var language_version : PipelineLanguageVersion | None

The type of the None singleton.

var model_config

The type of the None singleton.

var urn : str

The type of the None singleton.

var workflow_tags : PipelineTag | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowV3 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowV3 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of language_version
    if self.language_version:
        _dict['languageVersion'] = self.language_version.to_dict()
    # override the default output from pydantic by calling `to_dict()` of workflow_tags
    if self.workflow_tags:
        _dict['workflowTags'] = self.workflow_tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of analysis_storage
    if self.analysis_storage:
        _dict['analysisStorage'] = self.analysis_storage.to_dict()
    # set to None if language_version (nullable) is None
    # and model_fields_set contains the field
    if self.language_version is None and "language_version" in self.model_fields_set:
        _dict['languageVersion'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkflowV4 (**data: Any)

Expand source code

class WorkflowV4(BaseModel):
    """
    WorkflowV4
    """ # noqa: E501
    id: StrictStr
    code: Annotated[str, Field(min_length=1, strict=True, max_length=255)] = Field(description="The code of the workflow")
    urn: Annotated[str, Field(min_length=1, strict=True, max_length=2000)] = Field(description="The URN of the workflow. The format is urn:ilmn:ica:\\<type of the object\\>:\\<ID of the object\\>#\\<optional human readable hint representing the object\\>. The hint can be omitted, in that case the hashtag (#) must also be omitted.")
    description: Annotated[str, Field(min_length=1, strict=True, max_length=4000)] = Field(description="The description of the workflow")
    language_version: Optional[PipelineLanguageVersion] = Field(default=None, alias="languageVersion")
    workflow_tags: Optional[PipelineTag] = Field(default=None, alias="workflowTags")
    analysis_storage: AnalysisStorageV4 = Field(alias="analysisStorage")
    __properties: ClassVar[List[str]] = ["id", "code", "urn", "description", "languageVersion", "workflowTags", "analysisStorage"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkflowV4 from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of language_version
        if self.language_version:
            _dict['languageVersion'] = self.language_version.to_dict()
        # override the default output from pydantic by calling `to_dict()` of workflow_tags
        if self.workflow_tags:
            _dict['workflowTags'] = self.workflow_tags.to_dict()
        # override the default output from pydantic by calling `to_dict()` of analysis_storage
        if self.analysis_storage:
            _dict['analysisStorage'] = self.analysis_storage.to_dict()
        # set to None if language_version (nullable) is None
        # and model_fields_set contains the field
        if self.language_version is None and "language_version" in self.model_fields_set:
            _dict['languageVersion'] = None

        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkflowV4 from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "code": obj.get("code"),
            "urn": obj.get("urn"),
            "description": obj.get("description"),
            "languageVersion": PipelineLanguageVersion.from_dict(obj["languageVersion"]) if obj.get("languageVersion") is not None else None,
            "workflowTags": PipelineTag.from_dict(obj["workflowTags"]) if obj.get("workflowTags") is not None else None,
            "analysisStorage": AnalysisStorageV4.from_dict(obj["analysisStorage"]) if obj.get("analysisStorage") is not None else None
        })
        return _obj

WorkflowV4

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var analysis_storage : AnalysisStorageV4

The type of the None singleton.

var code : str

The type of the None singleton.

var description : str

The type of the None singleton.

var id : str

The type of the None singleton.

var language_version : PipelineLanguageVersion | None

The type of the None singleton.

var model_config

The type of the None singleton.

var urn : str

The type of the None singleton.

var workflow_tags : PipelineTag | None

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkflowV4 from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkflowV4 from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of language_version
    if self.language_version:
        _dict['languageVersion'] = self.language_version.to_dict()
    # override the default output from pydantic by calling `to_dict()` of workflow_tags
    if self.workflow_tags:
        _dict['workflowTags'] = self.workflow_tags.to_dict()
    # override the default output from pydantic by calling `to_dict()` of analysis_storage
    if self.analysis_storage:
        _dict['analysisStorage'] = self.analysis_storage.to_dict()
    # set to None if language_version (nullable) is None
    # and model_fields_set contains the field
    if self.language_version is None and "language_version" in self.model_fields_set:
        _dict['languageVersion'] = None

    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class Workgroup (**data: Any)

Expand source code

class Workgroup(BaseModel):
    """
    Workgroup
    """ # noqa: E501
    id: StrictStr
    name: Annotated[str, Field(min_length=1, strict=True, max_length=100)]
    description: Annotated[str, Field(min_length=1, strict=True, max_length=1000)]
    __properties: ClassVar[List[str]] = ["id", "name", "description"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of Workgroup from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of Workgroup from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "id": obj.get("id"),
            "name": obj.get("name"),
            "description": obj.get("description")
        })
        return _obj

Workgroup

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var description : str

The type of the None singleton.

var id : str

The type of the None singleton.

var model_config

The type of the None singleton.

var name : str

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of Workgroup from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of Workgroup from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias

class WorkgroupApi (api_client=None)

Expand source code

class WorkgroupApi:
    """NOTE: This class is auto generated by OpenAPI Generator
    Ref: https://openapi-generator.tech

    Do not edit the class manually.
    """

    def __init__(self, api_client=None) -> None:
        if api_client is None:
            api_client = ApiClient.get_default()
        self.api_client = api_client


    @validate_call
    def get_workgroup(
        self,
        workgroup_id: Annotated[StrictStr, Field(description="The ID of the workgroup to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> Workgroup:
        """Retrieve a workgroup.


        :param workgroup_id: The ID of the workgroup to retrieve (required)
        :type workgroup_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workgroup_serialize(
            workgroup_id=workgroup_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Workgroup",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_workgroup_with_http_info(
        self,
        workgroup_id: Annotated[StrictStr, Field(description="The ID of the workgroup to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[Workgroup]:
        """Retrieve a workgroup.


        :param workgroup_id: The ID of the workgroup to retrieve (required)
        :type workgroup_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workgroup_serialize(
            workgroup_id=workgroup_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Workgroup",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_workgroup_without_preload_content(
        self,
        workgroup_id: Annotated[StrictStr, Field(description="The ID of the workgroup to retrieve")],
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a workgroup.


        :param workgroup_id: The ID of the workgroup to retrieve (required)
        :type workgroup_id: str
        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workgroup_serialize(
            workgroup_id=workgroup_id,
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "Workgroup",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_workgroup_serialize(
        self,
        workgroup_id,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        if workgroup_id is not None:
            _path_params['workgroupId'] = workgroup_id
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/workgroups/{workgroupId}',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )




    @validate_call
    def get_workgroups(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> WorkgroupList:
        """Retrieve a list of workgroups.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workgroups_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkgroupList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        ).data


    @validate_call
    def get_workgroups_with_http_info(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> ApiResponse[WorkgroupList]:
        """Retrieve a list of workgroups.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workgroups_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkgroupList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        response_data.read()
        return self.api_client.response_deserialize(
            response_data=response_data,
            response_types_map=_response_types_map,
        )


    @validate_call
    def get_workgroups_without_preload_content(
        self,
        _request_timeout: Union[
            None,
            Annotated[StrictFloat, Field(gt=0)],
            Tuple[
                Annotated[StrictFloat, Field(gt=0)],
                Annotated[StrictFloat, Field(gt=0)]
            ]
        ] = None,
        _request_auth: Optional[Dict[StrictStr, Any]] = None,
        _content_type: Optional[StrictStr] = None,
        _headers: Optional[Dict[StrictStr, Any]] = None,
        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
    ) -> RESTResponseType:
        """Retrieve a list of workgroups.


        :param _request_timeout: timeout setting for this request. If one
                                 number provided, it will be total request
                                 timeout. It can also be a pair (tuple) of
                                 (connection, read) timeouts.
        :type _request_timeout: int, tuple(int, int), optional
        :param _request_auth: set to override the auth_settings for an a single
                              request; this effectively ignores the
                              authentication in the spec for a single request.
        :type _request_auth: dict, optional
        :param _content_type: force content-type for the request.
        :type _content_type: str, Optional
        :param _headers: set to override the headers for a single
                         request; this effectively ignores the headers
                         in the spec for a single request.
        :type _headers: dict, optional
        :param _host_index: set to override the host_index for a single
                            request; this effectively ignores the host_index
                            in the spec for a single request.
        :type _host_index: int, optional
        :return: Returns the result object.
        """ # noqa: E501

        _param = self._get_workgroups_serialize(
            _request_auth=_request_auth,
            _content_type=_content_type,
            _headers=_headers,
            _host_index=_host_index
        )

        _response_types_map: Dict[str, Optional[str]] = {
            '200': "WorkgroupList",
        }
        response_data = self.api_client.call_api(
            *_param,
            _request_timeout=_request_timeout
        )
        return response_data.response


    def _get_workgroups_serialize(
        self,
        _request_auth,
        _content_type,
        _headers,
        _host_index,
    ) -> RequestSerialized:

        _host = None

        _collection_formats: Dict[str, str] = {
        }

        _path_params: Dict[str, str] = {}
        _query_params: List[Tuple[str, str]] = []
        _header_params: Dict[str, Optional[str]] = _headers or {}
        _form_params: List[Tuple[str, str]] = []
        _files: Dict[
            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
        ] = {}
        _body_params: Optional[bytes] = None

        # process the path parameters
        # process the query parameters
        # process the header parameters
        # process the form parameters
        # process the body parameter


        # set the HTTP header `Accept`
        if 'Accept' not in _header_params:
            _header_params['Accept'] = self.api_client.select_header_accept(
                [
                    'application/problem+json', 
                    'application/vnd.illumina.v3+json'
                ]
            )


        # authentication setting
        _auth_settings: List[str] = [
            'JwtAuth', 
            'ApiKeyAuth'
        ]

        return self.api_client.param_serialize(
            method='GET',
            resource_path='/api/workgroups',
            path_params=_path_params,
            query_params=_query_params,
            header_params=_header_params,
            body=_body_params,
            post_params=_form_params,
            files=_files,
            auth_settings=_auth_settings,
            collection_formats=_collection_formats,
            _host=_host,
            _request_auth=_request_auth
        )

NOTE: This class is auto generated by OpenAPI Generator Ref: https://openapi-generator.tech

Do not edit the class manually.

Methods

def get_workgroup(self,
workgroup_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the workgroup to retrieve')]) ‑> Workgroup

Expand source code

@validate_call
def get_workgroup(
    self,
    workgroup_id: Annotated[StrictStr, Field(description="The ID of the workgroup to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> Workgroup:
    """Retrieve a workgroup.


    :param workgroup_id: The ID of the workgroup to retrieve (required)
    :type workgroup_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workgroup_serialize(
        workgroup_id=workgroup_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Workgroup",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a workgroup.

:param workgroup_id: The ID of the workgroup to retrieve (required) :type workgroup_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workgroup_with_http_info(self,
workgroup_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the workgroup to retrieve')]) ‑> ApiResponse[Workgroup]

Expand source code

@validate_call
def get_workgroup_with_http_info(
    self,
    workgroup_id: Annotated[StrictStr, Field(description="The ID of the workgroup to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[Workgroup]:
    """Retrieve a workgroup.


    :param workgroup_id: The ID of the workgroup to retrieve (required)
    :type workgroup_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workgroup_serialize(
        workgroup_id=workgroup_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Workgroup",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a workgroup.

:param workgroup_id: The ID of the workgroup to retrieve (required) :type workgroup_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workgroup_without_preload_content(self,
workgroup_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the workgroup to retrieve')]) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_workgroup_without_preload_content(
    self,
    workgroup_id: Annotated[StrictStr, Field(description="The ID of the workgroup to retrieve")],
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a workgroup.


    :param workgroup_id: The ID of the workgroup to retrieve (required)
    :type workgroup_id: str
    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workgroup_serialize(
        workgroup_id=workgroup_id,
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "Workgroup",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a workgroup.

:param workgroup_id: The ID of the workgroup to retrieve (required) :type workgroup_id: str :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workgroups(self) ‑> WorkgroupList

Expand source code

@validate_call
def get_workgroups(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> WorkgroupList:
    """Retrieve a list of workgroups.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workgroups_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkgroupList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    ).data

Retrieve a list of workgroups.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workgroups_with_http_info(self) ‑> ApiResponse[WorkgroupList]

Expand source code

@validate_call
def get_workgroups_with_http_info(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> ApiResponse[WorkgroupList]:
    """Retrieve a list of workgroups.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workgroups_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkgroupList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    response_data.read()
    return self.api_client.response_deserialize(
        response_data=response_data,
        response_types_map=_response_types_map,
    )

Retrieve a list of workgroups.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

def get_workgroups_without_preload_content(self) ‑> urllib3.response.HTTPResponse

Expand source code

@validate_call
def get_workgroups_without_preload_content(
    self,
    _request_timeout: Union[
        None,
        Annotated[StrictFloat, Field(gt=0)],
        Tuple[
            Annotated[StrictFloat, Field(gt=0)],
            Annotated[StrictFloat, Field(gt=0)]
        ]
    ] = None,
    _request_auth: Optional[Dict[StrictStr, Any]] = None,
    _content_type: Optional[StrictStr] = None,
    _headers: Optional[Dict[StrictStr, Any]] = None,
    _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
) -> RESTResponseType:
    """Retrieve a list of workgroups.


    :param _request_timeout: timeout setting for this request. If one
                             number provided, it will be total request
                             timeout. It can also be a pair (tuple) of
                             (connection, read) timeouts.
    :type _request_timeout: int, tuple(int, int), optional
    :param _request_auth: set to override the auth_settings for an a single
                          request; this effectively ignores the
                          authentication in the spec for a single request.
    :type _request_auth: dict, optional
    :param _content_type: force content-type for the request.
    :type _content_type: str, Optional
    :param _headers: set to override the headers for a single
                     request; this effectively ignores the headers
                     in the spec for a single request.
    :type _headers: dict, optional
    :param _host_index: set to override the host_index for a single
                        request; this effectively ignores the host_index
                        in the spec for a single request.
    :type _host_index: int, optional
    :return: Returns the result object.
    """ # noqa: E501

    _param = self._get_workgroups_serialize(
        _request_auth=_request_auth,
        _content_type=_content_type,
        _headers=_headers,
        _host_index=_host_index
    )

    _response_types_map: Dict[str, Optional[str]] = {
        '200': "WorkgroupList",
    }
    response_data = self.api_client.call_api(
        *_param,
        _request_timeout=_request_timeout
    )
    return response_data.response

Retrieve a list of workgroups.

:param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :type _request_timeout: int, tuple(int, int), optional :param _request_auth: set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request. :type _request_auth: dict, optional :param _content_type: force content-type for the request. :type _content_type: str, Optional :param _headers: set to override the headers for a single request; this effectively ignores the headers in the spec for a single request. :type _headers: dict, optional :param _host_index: set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request. :type _host_index: int, optional :return: Returns the result object.

class WorkgroupList (**data: Any)

Expand source code

class WorkgroupList(BaseModel):
    """
    WorkgroupList
    """ # noqa: E501
    items: List[Workgroup]
    __properties: ClassVar[List[str]] = ["items"]

    model_config = ConfigDict(
        populate_by_name=True,
        validate_assignment=True,
        protected_namespaces=(),
    )


    def to_str(self) -> str:
        """Returns the string representation of the model using alias"""
        return pprint.pformat(self.model_dump(by_alias=True))

    def to_json(self) -> str:
        """Returns the JSON representation of the model using alias"""
        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
        return json.dumps(self.to_dict())

    @classmethod
    def from_json(cls, json_str: str) -> Optional[Self]:
        """Create an instance of WorkgroupList from a JSON string"""
        return cls.from_dict(json.loads(json_str))

    def to_dict(self) -> Dict[str, Any]:
        """Return the dictionary representation of the model using alias.

        This has the following differences from calling pydantic's
        `self.model_dump(by_alias=True)`:

        * `None` is only added to the output dict for nullable fields that
          were set at model initialization. Other fields with value `None`
          are ignored.
        """
        excluded_fields: Set[str] = set([
        ])

        _dict = self.model_dump(
            by_alias=True,
            exclude=excluded_fields,
            exclude_none=True,
        )
        # override the default output from pydantic by calling `to_dict()` of each item in items (list)
        _items = []
        if self.items:
            for _item_items in self.items:
                if _item_items:
                    _items.append(_item_items.to_dict())
            _dict['items'] = _items
        return _dict

    @classmethod
    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
        """Create an instance of WorkgroupList from a dict"""
        if obj is None:
            return None

        if not isinstance(obj, dict):
            return cls.model_validate(obj)

        _obj = cls.model_validate({
            "items": [Workgroup.from_dict(_item) for _item in obj["items"]] if obj.get("items") is not None else None
        })
        return _obj

WorkgroupList

Create a new model by parsing and validating input data from keyword arguments.

Raises [ValidationError][pydantic_core.ValidationError] if the input data cannot be validated to form a valid model.

self is explicitly positional-only to allow self as a field name.

Ancestors

• pydantic.main.BaseModel

Class variables

var items : List[Workgroup]

The type of the None singleton.

var model_config

The type of the None singleton.

Static methods

def from_dict(obj: Optional[Dict[str, Any]]) ‑> Self | None

Create an instance of WorkgroupList from a dict

def from_json(json_str: str) ‑> Self | None

Create an instance of WorkgroupList from a JSON string

Methods

def to_dict(self) ‑> Dict[str, Any]

Expand source code

def to_dict(self) -> Dict[str, Any]:
    """Return the dictionary representation of the model using alias.

    This has the following differences from calling pydantic's
    `self.model_dump(by_alias=True)`:

    * `None` is only added to the output dict for nullable fields that
      were set at model initialization. Other fields with value `None`
      are ignored.
    """
    excluded_fields: Set[str] = set([
    ])

    _dict = self.model_dump(
        by_alias=True,
        exclude=excluded_fields,
        exclude_none=True,
    )
    # override the default output from pydantic by calling `to_dict()` of each item in items (list)
    _items = []
    if self.items:
        for _item_items in self.items:
            if _item_items:
                _items.append(_item_items.to_dict())
        _dict['items'] = _items
    return _dict

Return the dictionary representation of the model using alias.

This has the following differences from calling pydantic's self.model_dump(by_alias=True):

• None is only added to the output dict for nullable fields that were set at model initialization. Other fields with value None are ignored.

def to_json(self) ‑> str

Expand source code

def to_json(self) -> str:
    """Returns the JSON representation of the model using alias"""
    # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
    return json.dumps(self.to_dict())

Returns the JSON representation of the model using alias

def to_str(self) ‑> str

Expand source code

def to_str(self) -> str:
    """Returns the string representation of the model using alias"""
    return pprint.pformat(self.model_dump(by_alias=True))

Returns the string representation of the model using alias